bud 0.0.8 → 0.1.0.pre1

data/lib/bud/deploy/forkdeploy.rb

@@ -1,90 +0,0 @@
-require 'bud/deploy/deployer'
-
-module ForkDeployProtocol
-  state do
-    channel :child_ack, [:@loc, :node_id] => [:node_addr]
-  end
-end
-
-module ForkDeployChild
-  include ForkDeployProtocol
-
-  bootstrap do
-    child_ack <~ [[@deployer_addr, @node_id, ip_port]]
-  end
-end
-
-# An implementation of the Deployer that runs instances using forked local
-# processes (listening on an ephemeral port).
-#
-# Note that this module is included in both the deployer process and in the
-# deployed instances. To write code that only runs in one type of process,
-# consult the ":deploy" Bud option (which is false in deployed children).
-module ForkDeploy
-  include Deployer
-  include ForkDeployProtocol
-
-  def initialize(opts={})
-    super
-    @child_modules = [ForkDeployChild]
-    @child_pids = []
-    @dead_pids = []
-  end
-
-  bloom :child_info do
-    node <= child_ack {|a| [a.node_id, a.node_addr]}
-    node_ready <= child_ack {|a| [a.node_id]}
-  end
-
-  bootstrap do
-    return unless @options[:deploy]
-
-    Signal.trap("CHLD") do
-      # We receive SIGCHLD when a child process changes state; unfortunately,
-      # there's no easy way to tell whether the child process we're getting the
-      # signal for is one of ForkDeploy's children. Hence, check if any of the
-      # forked children have exited. We also ignore Errno::ECHILD, because
-      # someone else's waitpid() could easily race with us.
-      @child_pids.each do |c|
-        begin
-          pid = Process.waitpid(c, Process::WNOHANG)
-          unless pid.nil?
-            @dead_pids << pid
-          end
-        rescue Errno::ECHILD
-        end
-      end
-    end
-
-    on_shutdown do
-      # NB: Setting the SIGCHLD handler to "IGNORE" results in waitpid() being
-      # called automatically (to cleanup zombies), at least on OSX. This is not
-      # what we want, since it would cause a subsequent waitpid() to fail.
-      Signal.trap("CHLD", "DEFAULT")
-      pids = @child_pids - @dead_pids
-      pids.each do |p|
-        begin
-          Process.kill("TERM", p)
-          Process.waitpid(p)
-        rescue Errno::ESRCH
-        end
-      end
-    end
-
-    child_opts = @options[:deploy_child_opts]
-    child_opts ||= {}
-    deployer_addr = self.ip_port
-    node_count[[]].num.times do |i|
-      @child_pids << Bud.do_fork do
-        @child_modules.each do |m|
-          # XXX: Can this be done without "instance_eval"?
-          self.class.instance_eval "include #{m}"
-        end
-        child = self.class.new(child_opts)
-        child.instance_variable_set('@deployer_addr', deployer_addr)
-        child.instance_variable_set('@node_id', i)
-        child.run_fg
-      end
-    end
-  end
-end

data/lib/bud/deploy/threaddeploy.rb

@@ -1,38 +0,0 @@
-require 'bud/deploy/deployer'
-
-# An implementation of the Deployer that runs instances using the current Ruby
-# process (listening on an ephemeral port). ThreadDeploy is probably not the
-# best name: all the spawned instances are run by a single thread, they are just
-# multiplexed via EventMachine.
-#
-# Note that this module is included in both the deployer process and in the
-# deployed instances. To write code that only runs in one type of process,
-# consult the ":deploy" Bud option (which is false in deployed children).
-module ThreadDeploy
-  include Deployer
-
-  bootstrap do
-    return unless @options[:deploy]
-
-    @instances = []
-    on_shutdown do
-      @instances.each {|b| b.stop}
-    end
-
-    print "Spawning threads"
-    child_opts = @options[:deploy_child_opts]
-    child_opts ||= {}
-    deployer_addr = self.ip_port
-    node_count[[]].num.times do |i|
-      b = self.class.new(child_opts)
-      b.instance_variable_set('@deployer_addr', deployer_addr)
-      b.instance_variable_set('@node_id', i)
-      b.run_bg
-      @instances << b
-      node << [i, b.ip_port]
-      node_ready << [i]
-      print "."
-    end
-    puts "done"
-  end
-end

data/lib/bud/storage/tokyocabinet.rb

@@ -1,190 +0,0 @@
-begin
-  require 'tokyocabinet'
-  Bud::HAVE_TOKYOCABINET = true
-rescue LoadError
-end
-
-module Bud
-  # Persistent table implementation based on TokyoCabinet.
-  class BudTcTable < BudCollection # :nodoc: all
-    def initialize(name, bud_instance, given_schema)
-      tc_dir = bud_instance.options[:tc_dir]
-      raise Bud::Error, "TC support must be enabled via 'tc_dir'" unless tc_dir
-      if bud_instance.port.nil?
-        raise Bud::Error, "use of dbm storage requires an explicit port to be specified in Bud initialization options"
-      end
-
-      unless File.exists?(tc_dir)
-        Dir.mkdir(tc_dir)
-        puts "Created directory: #{tc_dir}" unless bud_instance.options[:quiet]
-      end
-
-      dirname = "#{tc_dir}/bud_#{bud_instance.port}"
-      unless File.exists?(dirname)
-        Dir.mkdir(dirname)
-        puts "Created directory: #{dirname}" unless bud_instance.options[:quiet]
-      end
-
-      super(name, bud_instance, given_schema)
-      @to_delete = []
-
-      @hdb = TokyoCabinet::HDB.new
-      db_fname = "#{dirname}/#{name}.tch"
-      flags = TokyoCabinet::HDB::OWRITER | TokyoCabinet::HDB::OCREAT
-      if bud_instance.options[:tc_truncate] == true
-        flags |= TokyoCabinet::HDB::OTRUNC
-      end
-      if !@hdb.open(db_fname, flags)
-        raise Bud::Error, "failed to open TokyoCabinet DB '#{db_fname}': #{@hdb.errmsg}"
-      end
-      @hdb.tranbegin
-    end
-
-    def init_storage
-      # XXX: we can't easily use the @storage infrastructure provided by
-      # BudCollection; issue #33
-      @storage = nil
-    end
-
-    def [](key)
-      check_enumerable(key)
-      key_s = MessagePack.pack(key)
-      val_s = @hdb[key_s]
-      if val_s
-        return make_tuple(key, MessagePack.unpack(val_s))
-      else
-        return @delta[key]
-      end
-    end
-
-    def has_key?(k)
-      check_enumerable(k)
-      key_s = MessagePack.pack(k)
-      return true if @hdb.has_key? key_s
-      return @delta.has_key? k
-    end
-
-    def include?(tuple)
-      key = get_key_vals(tuple)
-      value = self[key]
-      return (value == tuple)
-    end
-
-    def make_tuple(k_ary, v_ary)
-      t = Array.new(k_ary.length + v_ary.length)
-      @key_colnums.each_with_index do |k,i|
-        t[k] = k_ary[i]
-      end
-      val_cols.each_with_index do |c,i|
-        t[cols.index(c)] = v_ary[i]
-      end
-      tuple_accessors(t)
-    end
-
-    def each(&block)
-      each_from([@delta], &block)
-      each_storage(&block)
-    end
-
-    def each_from(bufs, &block)
-      bufs.each do |b|
-        if b == @storage then
-          each_storage(&block)
-        else
-          b.each_value do |v|
-            tick_metrics if bud_instance.options[:metrics]
-            yield v
-          end
-        end
-      end
-    end
-
-    def each_storage(&block)
-      @hdb.each do |k,v|
-        k_ary = MessagePack.unpack(k)
-        v_ary = MessagePack.unpack(v)
-        tick_metrics if bud_instance.options[:metrics]
-        yield make_tuple(k_ary, v_ary)
-      end
-    end
-
-    def flush
-      @hdb.trancommit
-    end
-
-    def close
-      @hdb.close
-    end
-
-    def merge_to_hdb(buf)
-      buf.each do |key,tuple|
-        merge_tuple_to_hdb(key, tuple)
-      end
-    end
-
-    def merge_tuple_to_hdb(key, tuple)
-      val = val_cols.map{|c| tuple[cols.index(c)]}
-      key_s = MessagePack.pack(key)
-      val_s = MessagePack.pack(val)
-      if @hdb.putkeep(key_s, val_s) == false
-        old_tuple = self[key]
-        raise_pk_error(tuple, old_tuple) if tuple != old_tuple
-      end
-    end
-
-    # move deltas to TC, and new_deltas to deltas
-    def tick_deltas
-      merge_to_hdb(@delta)
-      @delta = @new_delta
-      @new_delta = {}
-    end
-
-    superator "<-" do |o|
-      o.each do |tuple|
-        @to_delete << tuple unless tuple.nil?
-      end
-    end
-
-    def insert(tuple)
-      tuple = prep_tuple(tuple)
-      key = get_key_vals(tuple)
-      merge_tuple_to_hdb(key, tuple)
-    end
-
-    alias << insert
-
-    # Remove to_delete and then add pending to HDB
-    def tick
-      raise Bud::Error, "orphaned tuples in @delta for #{@tabname}" unless @delta.empty?
-      raise Bud::Error, "orphaned tuples in @new_delta for #{@tabname}" unless @new_delta.empty?
-
-      @to_delete.each do |tuple|
-        k = get_key_vals(tuple)
-        k_str = MessagePack.pack(k)
-        cols_str = @hdb[k_str]
-        unless cols_str.nil?
-          hdb_cols = MessagePack.unpack(cols_str)
-          delete_cols = val_cols.map{|c| tuple[cols.index(c)]}
-          if hdb_cols == delete_cols
-            @hdb.delete k_str
-          end
-        end
-      end
-      @to_delete = []
-
-      merge_to_hdb(@pending)
-      @pending = {}
-
-      @hdb.trancommit
-      @hdb.tranbegin
-    end
-
-    def length
-      @hdb.length
-    end
-
-    def empty?
-      @hdb.empty?
-    end
-  end
-end

data/lib/bud/stratify.rb

@@ -1,85 +0,0 @@
-require 'rubygems'
-require 'bud'
-
-class Stratification # :nodoc: all
-  include Bud
-
-  state do
-    # Data inserted by client (Bud rewrite code)
-    table :depends, [:rule, :head, :op, :body, :neg]
-
-    # Intermediate state
-    scratch :depends_clean, [:head, :body, :neg, :temporal]
-    scratch :depends_tc, [:head, :body, :via, :neg, :temporal]
-    scratch :stratum_base, [:predicate, :stratum]
-
-    # Output state
-    scratch :cycle, [:predicate, :via, :neg, :temporal]
-    scratch :stratum, [:predicate, :stratum]
-    scratch :top_strat, [:stratum]
-  end
-
-  def declaration
-    strata[0] = lambda {
-      depends_clean <= depends do |d|
-        is_temporal = (d.op.to_s =~ /<[\+\-\~]/)
-        [d.head, d.body, d.neg, is_temporal]
-      end
-
-      # Compute the transitive closure of "depends_clean" to detect cycles in
-      # the deductive fragment of the program.
-      depends_tc <= depends_clean do |d|
-        [d.head, d.body, d.body, d.neg, d.temporal]
-      end
-      depends_tc <= (depends_clean * depends_tc).pairs(:body => :head) do |b, r|
-        [b.head, r.body, b.body, (b.neg or r.neg), (b.temporal or r.temporal)]
-      end
-
-      cycle <= depends_tc do |d|
-        if d.head == d.body
-          if d.neg and !d.temporal
-            raise Bud::CompileError, "unstratifiable program: #{d.inspect}"
-          else
-            [d.head, d.via, d.neg, d.temporal]
-          end
-        end
-      end
-    
-      # we initially assign all predicates to stratum 0
-      stratum_base <= depends {|d| [d.body, 0]}
-    }
-
-    strata[1] = lambda {
-      # classic stratification:
-      # if A depends on B, A is >= B.
-      # if A depends nonmonotonically on B, A > B.
-      # if A are B are nonmonotonically co-dependent, give up. 
-      #  (don't need to do this, b/c we've ruled out deductive cycles)
-      #
-      # Stratum choice controls local evaluation order, so we need only consider
-      # deductive rules (<=). Temporal rules are placed in an extra "top"
-      # stratum afterward.
-      stratum_base <= (depends * stratum_base).pairs(:body => :predicate) do |d, s|
-        if d.op.to_s == '<='
-          if d.neg
-            # BUMP
-            [d.head, s.stratum + 1]
-          else
-            # HOIST
-            [d.head, s.stratum]
-          end
-        end
-      end
-    }
-
-    strata[2] = lambda {
-      stratum <= stratum_base.group([stratum_base.predicate], max(stratum_base.stratum))
-    }
-
-    strata[3] = lambda {
-      # there is no good reason that top_strat can't be computed in strata[2] over stratum_base.
-      # however, when it is deduced that way, it is empty after a tick
-      top_strat <= stratum.group([], max(stratum.stratum))
-    }
-  end
-end