tupelo 0.21 → 0.22

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

@@ -1,86 +0,0 @@
-require 'tupelo/client'
-require 'funl/history-client'
-
-class Tupelo::PersistentArchiver < Tupelo::Client; end
-
-require 'tupelo/tuplets/persistent-archiver/worker'
-require 'tupelo/tuplets/persistent-archiver/tuplespace'
-
-module Tupelo
-  class PersistentArchiver
-    include Funl::HistoryClient
-
-    attr_reader :server
-    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::PersistentArchiver::Tuplespace, **opts
-      @server = server
-    end
-
-    # three kinds of requests:
-    #
-    # 1. fork a new client, with given Client class, and subselect
-    #   using given templates
-    #
-    # 2. accept tcp/unix socket connection and fork, and then:
-    #
-    #   a. dump subspace 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
-    # do this by passing cmd to worker thread, with conn
-    class ForkRequest
-      attr_reader :io
-      def initialize io
-        @io = io
-      end
-    end
-
-    def make_worker
-      Tupelo::PersistentArchiver::Worker.new self
-    end
-
-    def start
-      ## load from file?
-      super # start worker thread
-      @server_thread = Thread.new do
-        run
-      end
-    end
-
-    def stop
-      server_thread.kill if server_thread
-      super # stop worker thread
-    end
-
-    def run
-      loop do
-        ## nonblock_accept?
-        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
-      raise
-    end
-
-    def handle_conn conn
-      log.debug {"accepted #{conn.inspect}"}
-      begin
-        worker << ForkRequest.new(conn)
-      rescue => ex
-        log.error ex
-        raise
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'sequel'
-
-class Tupelo::PersistentArchiver
-  class Tuplespace
-    include Enumerable
-    
-    attr_reader :zero_tolerance
-
-    def initialize(file: ":memory:",
-                   zero_tolerance: Tupelo::Archiver::ZERO_TOLERANCE)
-      @db = Sequel.sqlite(:database => file)
-      @nzero = 0
-      @zero_tolerance = zero_tolerance
-    end
-    
-    # note: multiple equal tuples are yielded once
-    def each
-      @db[:tuples].select(:packed, :count).each do |row| ## select as array?
-        packed, count = row.values_at(:packed, :count)
-        yield packed, count if count > 0
-      end
-    end
-    
-    def insert packed
-      if packed has exact match in data table
-        inc count
-      else
-        let hash = packed_hash(str)
-        select rows with this hash
-
-        if op is insert
-          if rows.count == 0, insert new row, with count=1
-          else find row using packed_compare(str, packed_tuple)
-            if found, increment count
-            else insert new row, with count=1
-
-
-      @db[:tuples].insert 
-      @counts[tuple] += 1
-    end
-    
-    def delete_once tuple
-      if @counts[tuple] > 0
-        @counts[tuple] -= 1
-        if @counts[tuple] == 0
-          @nzero += 1
-          clear_excess_zeros if @nzero > zero_tolerance
-        end
-        true
-      else
-        false
-      end
-    end
-
-    def transaction inserts: [], deletes: []
-      deletes.each do |tuple|
-        delete_once tuple or raise "bug"
-      end
-
-      inserts.each do |tuple|
-        insert tuple.freeze ## freeze recursively
-      end
-    end
-
-    def clear_excess_zeros
-      nd = (@nzero - zero_tolerance / 2)
-      @counts.delete_if {|tuple, count| count == 0 && (nd-=1) >= 0}
-    end
-
-    def find_distinct_matches_for tuples
-      h = Hash.new(0)
-      tuples.map do |tuple|
-        if @counts[tuple] > h[tuple]
-          h[tuple] += 1
-          tuple
-        else
-          nil
-        end
-      end
-    end
-
-    def find_match_for tuple
-      @counts[tuple] > 0 && tuple
-    end
-
-###    def find_match_for tuple, distinct_from: []
-###      tuple && @tuple_rec[tuple].count > distinct_from.count(tuple)
-###      ## is 'tuple &&' necessary?
-###    end
-  end
-end

data/lib/tupelo/tuplets/persistent-archiver/worker.rb

@@ -1,114 +0,0 @@
-require 'funl/history-worker'
-
-class Tupelo::PersistentArchiver
-  class Worker < Tupelo::Client::Worker
-    include Funl::HistoryWorker
-    
-    def initialize *args
-      super
-      @scheduled_actions = Hash.new {|h,k| h[k] = []}
-    end
-
-    def handle_client_request req
-      case req
-      when Tupelo::Archiver::ForkRequest
-        handle_fork_request req
-      else
-        super
-      end
-    end
-
-    def handle_fork_request req
-      stream = client.arc_server_stream_for req.io
-
-      begin
-        op, tags, tick = stream.read
-      rescue EOFError
-        log.debug {"#{stream.peer_name} disconnected from archiver"}
-        return
-      rescue => ex
-        log.error "in fork for #{stream || req.io}: #{ex.inspect}"
-      end
-
-      log.info {
-        "#{stream.peer_name} requested #{op.inspect} at tick=#{tick}" +
-          (tags ? " on #{tags}" : "")}
-
-      if tick <= global_tick
-        fork_for_op op, tags, tick, stream, req
-      else
-        at_tick tick do
-          fork_for_op op, tags, tick, stream, req
-        end
-      end
-    end
-
-    def fork_for_op op, tags, tick, stream, req
-      fork do
-        begin
-          case op
-          when "new client"
-            raise "Unimplemented" ###
-          when "get range" ### handle this in Funl::HistoryWorker
-            raise "Unimplemented" ###
-          when GET_TUPLESPACE
-            send_tuplespace stream, tags
-          else
-            raise "Unknown operation: #{op.inspect}"
-          end
-        rescue EOFError
-          log.debug {"#{stream.peer_name} disconnected from archiver"}
-        rescue => ex
-          log.error "in fork for #{stream || req.io}: #{ex.inspect}"
-        end
-      end
-    ensure
-      req.io.close
-    end
-    
-    def at_tick tick, &action
-      @scheduled_actions[tick] << action
-    end
-
-    def handle_message msg
-      super
-      actions = @scheduled_actions.delete(global_tick)
-      actions and actions.each do |action|
-        action.call
-      end
-    end
-
-    def send_tuplespace stream, templates
-      log.info {
-        "send_tuplespace to #{stream.peer_name} " +
-        "at tick #{global_tick.inspect} " +
-        (templates ? " with templates #{templates.inspect}" : "")}
-      
-      stream << [global_tick]
-
-      if templates
-        templates = templates.map {|t| Tupelo::Client::Template.new t}
-        tuplespace.each do |tuple, count|
-          if templates.any? {|template| template === tuple}
-            count.times do
-              stream << tuple
-              ## optimization: use stream.write_to_buffer
-            end
-          end
-          ## optimize this if templates have simple form, such as
-          ##   [ [str1, nil, ...], [str2, nil, ...], ...]
-        end
-      else
-        tuplespace.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
-          end
-        end
-      end
-
-      stream << nil # terminator
-      ## stream.flush or close if write_to_buffer used above
-    end
-  end
-end