bud 0.0.2

data/lib/bud/bud_meta.rb

@@ -0,0 +1,185 @@
+require 'bud/rewrite'
+require 'bud/state'
+require 'parse_tree'
+require 'pp'
+
+class BudMeta #:nodoc: all
+  attr_reader :depanalysis
+
+  def initialize(bud_instance, declarations)
+    @bud_instance = bud_instance
+    @declarations = declarations
+  end
+
+  def meta_rewrite
+    shred_rules
+    top_stratum = stratify
+    stratum_map = binaryrel2map(@bud_instance.t_stratum)
+
+    rewritten_strata = Array.new(top_stratum + 2) { [] }
+    @bud_instance.t_rules.each do |d|
+      if d.op.to_s == '<='
+        # deductive rules are assigned to strata based on
+        # the basic datalog stratification algorithm
+        belongs_in = stratum_map[d.lhs]
+        belongs_in ||= 0
+        rewritten_strata[belongs_in] << d.src
+      else
+        # all temporal rules are placed in the last stratum
+        rewritten_strata[top_stratum + 1] << d.src
+      end
+    end
+
+    @depanalysis = DepAnalysis.new
+    @bud_instance.t_depends_tc.each {|d| @depanalysis.depends_tc << d}
+    @bud_instance.t_provides.each {|p| @depanalysis.providing << p}
+    3.times { @depanalysis.tick }
+
+    @depanalysis.underspecified.each do |u|
+      puts "Warning: underspecified dataflow: #{u.inspect}"
+      @bud_instance.t_underspecified << u
+    end
+    dump_rewrite(rewritten_strata) if @bud_instance.options[:dump_rewrite]
+
+    return rewritten_strata
+  end
+
+  def binaryrel2map(rel)
+    map = {}
+    rel.each do |s|
+      raise Bud::BudError unless s.length == 2
+      map[s[0]] = s[1]
+    end
+    return map
+  end
+
+  def shred_rules
+    # to completely characterize the rules of a bud class we must extract
+    # from all parent classes/modules
+    # after making this pass, we no longer care about the names of methods.
+    # we are shredding down to the granularity of rule heads.
+    seed = 0
+    rulebag = {}
+    @bud_instance.class.ancestors.reverse.each do |anc|
+      @declarations.each do |meth_name|
+        rw = rewrite_rule_block(anc, meth_name, seed)
+        if rw
+          seed = rw.rule_indx
+          rulebag[meth_name] = rw
+        end
+      end
+    end
+
+    rulebag.each_value do |v|
+      v.rules.each {|r| @bud_instance.t_rules << r}
+      v.depends.each {|d| @bud_instance.t_depends << d}
+    end
+  end
+
+  def rewrite_rule_block(klass, block_name, seed)
+    parse_tree = ParseTree.translate(klass, block_name)
+    return unless parse_tree.first
+
+    pt = Unifier.new.process(parse_tree)
+    pp pt if @bud_instance.options[:dump_ast]
+    begin
+      check_rule_ast(pt)
+    rescue Exception => e
+      # try to "generate" the source code associated with the problematic
+      # block, so as to generate a more meaningful error message.
+      # if this parse fails, return the original exception (not the new one).
+      begin
+        code = Ruby2Ruby.new.process(pt)
+      rescue Exception => sub_e
+        raise e, "Error parsing rule block #{block_name}.  Could not extract source."
+      end
+      raise e, "Error parsing rule block #{block_name}:\n#{code}"
+    end
+
+    rewriter = RuleRewriter.new(seed, @bud_instance)
+    rewriter.process(pt)
+    return rewriter
+  end
+
+  # Perform some basic sanity checks on the AST of a rule block. We expect a
+  # rule block to consist of a :defn, a nested :scope, and then a sequence of
+  # statements. Each statement is a :call node.
+  def check_rule_ast(pt)
+    # :defn format: node tag, block name, args, nested scope
+    raise Bud::CompileError if pt.sexp_type != :defn
+    scope = pt[3]
+    raise Bud::CompileError if scope.sexp_type != :scope
+    block = scope[1]
+
+    block.each_with_index do |n,i|
+      if i == 0
+        raise Bud::CompileError if n != :block
+        next
+      end
+
+      raise Bud::CompileError if n.sexp_type != :call
+      raise Bud::CompileError unless n.length == 4
+
+      # Rule format: call tag, lhs, op, rhs
+      tag, lhs, op, rhs = n
+
+      # Check that LHS references a named collection
+      raise Bud::CompileError if lhs.nil? or lhs.sexp_type != :call
+      lhs_name = lhs[2]
+      unless @bud_instance.tables.has_key? lhs_name.to_sym
+        raise Bud::CompileError, "Table does not exist: '#{lhs_name}'"
+      end
+
+      # Check that op is a legal Bloom operator
+      unless [:<, :<=].include? op
+        raise Bud::CompileError, "Illegal operator: '#{op}'"
+      end
+
+      # Check superator invocation. A superator that begins with "<" is parsed
+      # as a call to the binary :< operator. The right operand to :< is a :call
+      # node; the LHS of the :call is the actual rule body, the :call's oper is
+      # the rest of the superator (unary ~, -, +), and the RHS is empty.  Note
+      # that ParseTree encodes unary "-" and "+" as :-@ and :-+, respectively.
+      # XXX: We don't check for illegal superators (e.g., "<--"). That would be
+      # tricky, because they are encoded as a nested unary op in the rule body.
+      if op == :<
+        raise Bud::CompileError unless rhs.sexp_type == :arglist
+        body = rhs[1]
+        raise Bud::CompileError unless body.sexp_type == :call
+        op_tail = body[2]
+        raise Bud::CompileError unless [:~, :-@, :+@].include? op_tail
+        rhs_args = body[3]
+        raise Bud::CompileError unless rhs_args.sexp_type == :arglist
+        raise Bud::CompileError if rhs_args.length != 1
+      end
+    end
+  end
+
+  def stratify
+    strat = Stratification.new
+    @bud_instance.t_depends.each {|d| strat.depends << d}
+    strat.tick
+
+    # Copy computed data back into Bud runtime
+    strat.stratum.each {|s| @bud_instance.t_stratum << s}
+    strat.depends_tc.each {|d| @bud_instance.t_depends_tc << d}
+    strat.cycle.each {|c| @bud_instance.t_cycle << c}
+    if strat.top_strat.length > 0
+      top = strat.top_strat.first.stratum
+    else
+      top = 1
+    end
+    return top
+  end
+
+  def dump_rewrite(strata)
+    fout = File.new("#{@bud_instance.class}_rewritten.txt", "w")
+    fout.puts "Declarations:"
+
+    strata.each_with_index do |src_ary, i|
+      text = src_ary.join("\n")
+      fout.puts "R[#{i}]:\n#{text}"
+    end
+    fout.close
+  end
+end

data/lib/bud/bust/bust.rb

@@ -0,0 +1,126 @@
+require 'rubygems'
+require 'bud'
+require 'json'
+require 'socket'
+require 'uri'
+require 'cgi'
+
+HTTP_VERBS = ["GET", "POST"] #, "DELETE"]
+
+# a RESTful interface to Bloom code
+module Bust
+  include Bud
+
+  # used this for inspiration:
+  # http://blogs.msdn.com/b/abhinaba/archive/2005/10/14/474841.aspx
+
+  # allow state to be queried easily
+  state do
+    table :t_table_info, [:tab_name, :tab_type]
+    table :t_table_schema, [:tab_name, :scheme]
+  end
+
+  bootstrap do
+    # copied from peter's code; this should probably be in the Bud runtime or in
+    # some meta module
+    @tables.each do |t|
+      t_table_schema << [t[0], t[1].schema.clone]
+      t_table_info << [t[0], t[1].class.to_s]
+    end
+
+    q = Queue.new
+    Thread.start(self) do |bud|
+      BustClass.new(bud, q)
+    end
+    # Wait for socket to be ready before we return from bootstrap.
+    q.pop
+  end
+
+  class BustClass
+
+    class BustHandler
+      def initialize(session, request, body, bud)
+        @session = session
+        @request = request
+        @body = body
+        @bud = bud
+      end
+
+      def serve()
+        puts "Request: " + @request
+        puts "Body: " + @body.inspect if @body
+
+        for type in HTTP_VERBS
+          if @request =~ Regexp.new(type + " .* HTTP*")
+            break reqstr = @request.gsub(Regexp.new(type + " "), '').gsub(/ HTTP.*/, '')
+          end
+        end
+
+        uri = URI.parse(reqstr)
+        uri_params = {}
+        uri_params = CGI.parse(uri.query) if uri.query
+        table_name = uri.path[1..-1].split(".")[0] # hack; we always return JSON
+        # "Access-Control-Allow-Origin: *" disables same-origin policy to allow
+        # XMLHttpRequests from any origin
+        success = "HTTP/1.1 200 OK\r\nServer: Bud\r\nContent-type: application/json\r\nAccess-Control-Allow-Origin: *\r\n\r\n"
+        failure = "HTTP/1.1 404 Object Not Found\r\nServer: Bud\r\nAccess-Control-Allow-Origin: *\r\n\r\n"
+
+        begin
+          if @request =~ /GET .* HTTP*/
+            puts "GET shouldn't have body" if @body
+            # select the appropriate elements from the table
+            desired_elements = (eval "@bud." + table_name).find_all do |t|
+              uri_params.all? {|k, v| (eval "t." + k.to_s) == v[0]}
+            end
+            @session.print success
+            @session.print desired_elements.to_json
+          elsif @request =~ /POST .* HTTP*/
+            # instantiate a new tuple
+            tuple_to_insert = []
+            @body.each do |k, v|
+              index = (eval "@bud." + table_name).schema.find_index(k.to_sym)
+              for i in (tuple_to_insert.size..index)
+                tuple_to_insert << nil
+              end
+              tuple_to_insert[index] = v[0]
+            end
+            # actually insert the puppy
+            @bud.async_do { (eval "@bud." + table_name) << tuple_to_insert }
+            @session.print success
+          end
+        rescue Exception
+          puts "exception: #{$!}"
+          @session.print failure
+        ensure
+          @session.close
+        end
+
+      end
+    end
+
+    def initialize(bud, q)
+      # allow user-configurable port
+      server = TCPServer.new(bud.ip, (bud.options[:bust_port] or 8080))
+      # We're now ready to accept connections.
+      q << true
+
+      loop do
+        session = server.accept
+        request = session.gets
+        length = nil
+        body = nil
+        while req = session.gets
+          length = Integer(req.split(" ")[1]) if req.match(/^Content-Length:/)
+          if req.match(/^\r\n$/)
+            body = CGI.parse(session.read(length)) if length
+            break
+          end
+        end
+        Thread.start(session, request, body, bud) do |session, request, body, bud|
+          BustHandler.new(session, request, body, bud).serve()
+        end
+      end
+    end
+
+  end
+end

data/lib/bud/bust/client/idempotence.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bud'
+
+module Idempotence #:nodoc: all
+  state do
+    table :dead, [:dead]
+  end
+
+  def bust_idempotent(r) (dead.include? r) ? false : dead.insert(r) end
+end

data/lib/bud/bust/client/restclient.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bud'
+require 'nestful'
+require 'bud/bust/client/idempotence'
+
+module RestClient
+  include Idempotence # :nodoc: all
+
+  state do
+    # complains about underspecified dataflow because it can't see the
+    # nested rules...
+    interface input, :rest_req, [:rid, :verb, :form, :url, :params]
+    interface output, :rest_response, [:rid, :resp, :exception]
+
+    # we don't really need to store this i suppose
+    scratch :rest_req_thread, [:thread]
+  end
+
+  bloom :rest_client do
+    rest_req_thread <= rest_req.map do |req|
+      # start up a new thread to deal with the response
+      [Thread.start(req, self) do |r, bud|
+         params = (r.params or {})
+         begin
+           case r.verb
+           when :get
+             get_hash = {:params => params}
+             get_hash[:format] = r.form if r.form
+             resp_tuple = [r.rid, Nestful.get(r.url, get_hash), false]
+           when :post
+             # not sure if this is a sensible default for format?
+             format = (r.form or :form)
+             resp_tuple = [r.rid, Nestful.post(r.url, :format => format,
+                                               :params => params), false]
+           else
+             raise "invalid verb"
+           end
+         rescue
+           resp_tuple = [r.rid, "#{$!}", true]
+         end
+         # insert the response
+         bud.async_do do
+           rest_response <+ [resp_tuple]
+         end
+       end] if bust_idempotent [[req.rid, req.verb, req.form, req.url, req.params,
+                                 @budtime]]
+    end
+  end
+end