bud 0.0.3 → 0.0.4

data/lib/bud/viz.rb

@@ -9,19 +9,17 @@ class VizOnline #:nodoc: all
     @bud_instance = bud_instance
     return if bud_instance.class == Stratification or @bud_instance.class == DepAnalysis
     @meta_tables = {'t_rules' => 1, 't_depends' => 1, 't_table_info' => 1, 't_cycle' => 1, 't_stratum' => 1, 't_depends_tc' => 1, 't_table_schema' => 1}
-    @bud_instance.options[:tc_dir] = "TC_#{@bud_instance.class}_#{bud_instance.options[:tag]}_#{bud_instance.object_id}_#{bud_instance.port}"
-    @table_info = new_tab(:t_table_info, [:tab_name, :tab_type], @bud_instance)
-    @table_schema = new_tab(:t_table_schema, [:tab_name, :col_name, :ord], @bud_instance)
-
-    @logtab = {}
+    @bud_instance.options[:dbm_dir] = "DBM_#{@bud_instance.class}_#{bud_instance.options[:tag]}_#{bud_instance.object_id}_#{bud_instance.port}"
+    @table_info = bud_instance.tables[:t_table_info]
+    @table_schema = bud_instance.tables[:t_table_schema]
+    @logtab = new_tab("the_big_log", [:table, :time, :contents], bud_instance)
     tmp_set = []
     @bud_instance.tables.each do |name, tbl|
-      next if name.to_s =~ /_vizlog\z/
-
+      next if name == "the_big_log"
       # Temp collections don't have a schema until a fact has been inserted into
       # them; for now, we just include an empty schema for them in the viz
       if tbl.schema.nil?
-        schema = []
+        schema = [:a, :b, :c, :d]
       else
         schema = tbl.schema.clone
       end
@@ -30,36 +28,52 @@ class VizOnline #:nodoc: all
 
     tmp_set.each do |t|
       news = [:c_bud_time]
+      snd_alias = t[0].to_s + "_snd"
       @table_schema << [t[0], :c_bud_time, 0]
       t[1].each_with_index do |s, i|
         news << s
         @table_schema << [t[0], s, i+1]
+        if t[2] == "Bud::BudChannel"
+          @table_schema << [snd_alias, s, i+1]
+        end
       end
       lt = "#{t[0]}_vizlog".to_sym
-      @logtab[t[0]] = new_tab(lt, news, @bud_instance)
+      if t[2] == "Bud::BudChannel"
+        lts = "#{snd_alias}_vizlog".to_sym
+        @table_info << [snd_alias, t[2]] 
+      end
       @table_info << [t[0], t[2]]
     end
   end
 
   def new_tab(name, schema, instance)
-    ret = Bud::BudTcTable.new(name, instance, schema)
+    ret = Bud::BudDbmTable.new(name, instance, schema)
     instance.tables[name] = ret
     return ret
   end
 
+  def add_rows(collection, tab)
+    collection.each do |row|
+      if collection.class == Hash
+        row = row[1]
+      end
+      newrow = [tab, @bud_instance.budtime, row]
+      @logtab << newrow
+
+    end
+  end
+
   def do_cards
     return if @bud_instance.class == Stratification or @bud_instance.class == DepAnalysis
     @bud_instance.tables.each do |t|
       tab = t[0]
-      next if tab.to_s =~ /_vizlog\z/
+      next if tab == "the_big_log"
       next if @meta_tables[tab.to_s] and @bud_instance.budtime > 0
-      next unless @logtab[tab]
-      t[1].each do |row|
-        newrow = [@bud_instance.budtime]
-        row.each{ |r| newrow << r }
-        @logtab[tab] << newrow
+      add_rows(t[1], tab) unless t[1].class == Bud::BudPeriodic
+      if t[1].class == Bud::BudChannel
+        add_rows(t[1].pending, "#{tab}_snd")
       end
-      @logtab[tab].tick
+      @logtab.tick
     end
   end
 end

data/lib/bud/viz_util.rb

@@ -0,0 +1,204 @@
+require 'rubygems'
+require 'bud/graphs'
+
+module TraceCardinality
+  state do
+    table :full_info, [:bud_time, :table, :row]
+    scratch :cardinalities, [:bud_time, :table] => [:cnt]
+    scratch :times, [:bud_time]
+  end
+
+  bloom do
+    cardinalities <= full_info.group([full_info.bud_time, full_info.table], count)
+    times <= full_info {|f| [f.bud_time]}
+  end
+end
+
+module VizUtil #:nodoc: all
+  def graph_from_instance(bud_instance, viz_name, output_base, collapse=true, fmt=nil)
+    tabinf = {}
+    bud_instance.tables.each do |t|
+      tab = t[0].to_s
+      tabinf[tab] = t[1].class.to_s
+    end
+    write_graphs(tabinf, bud_instance.t_cycle, bud_instance.t_depends, bud_instance.t_rules, viz_name, output_base, fmt, collapse, bud_instance.meta_parser.depanalysis)
+  end
+
+  def write_graphs(tabinf, cycle, depends, rules, viz_name, output_base, fmt, collapse, depanalysis=nil, budtime=-1, card_info=nil)
+    staging = "#{viz_name}.staging"
+    gv = GraphGen.new(tabinf, cycle, staging, budtime, collapse, card_info)
+    gv.process(depends)
+    dump(rules, output_base, gv)
+    gv.finish(depanalysis, fmt)
+    inject_js(staging, "#{viz_name}.svg")
+    File.delete(staging)
+  end
+
+  def inject_js(input, fname)
+    fin = File.open(input, "r")
+    fout = File.open(fname, "w")
+    while line = fin.gets
+      fout.puts line.gsub("<title>G</title>", svg_javascript)
+    end
+    fin.close
+    fout.close
+  end
+
+  def dump(shredded_rules, output_base, gv_obj)
+    return if shredded_rules.nil?
+
+    fout = File.new("#{output_base}/style.css", "w")
+    fout.puts css
+    fout.close
+    code = {}
+    rules = {}
+    convertor = Syntax::Convertors::HTML.for_syntax "ruby"
+    shredded_rules.each do |s|
+      fout = File.new("#{output_base}/#{s[0]}.html", "w+")
+      fout.puts header
+      fout.puts "<h1>Rule #{s[0]}</h1><br>"
+
+      c = convertor.convert(s[4])
+      c.sub!(/^<pre>/, "<pre class=\"code\" style='font-size:20px'>\n")
+      fout.puts c
+      rules[s[0]] = [s[1], s[4]]
+      fout.close
+    end
+
+    rules.each_pair do |k, v|
+      if !code[v[0]]
+        code[v[0]] = ""
+      end
+      #code[v[0]] = "<br># RULE #{k}<br> " + code[v[0]] + "<br>" + v[1]
+      code[v[0]] = "\n# RULE #{k}\n " + code[v[0]] + "\n" + v[1]
+    end
+    gv_obj.nodes.each_pair do |k, v|
+      fout = File.new("#{output_base}/#{k}.html", "w+")
+      fout.puts header
+      k.split(", ").each do |i|
+        unless code[i].nil?
+          c = convertor.convert(code[i])
+          c.sub!(/^<pre>/, "<pre class=\"code\">\n")
+          fout.puts c
+        end
+      end
+      fout.puts("</body></html>")
+      fout.close
+    end
+  end
+
+  def header
+    return "<html><meta content='text/html; charset=UTF-8' http-equiv='Content-Type'/>\n<head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\" /></head><body>"
+  end
+
+  def css
+    return <<END_CSS
+pre.code {
+  padding: 1ex 1ex 1ex 1ex;
+  border: 4px groove #CC0000;
+  overflow-x: auto;
+}
+
+pre.code span.attribute { color: #009900; }
+pre.code span.char { color: #F00; }
+pre.code span.class { color: #A020F0; font-weight: bold; }
+pre.code span.comment { color: #0000FF; }
+pre.code span.constant { color: #008B8B; }
+pre.code span.escape { color: #6A5ACD; }
+pre.code span.expr { color: #2222CC; }
+pre.code span.global { color: #11AA44; }
+pre.code span.ident { color: #000000; }
+pre.code span.keyword { color: #A52A2A; font-weight: bold; }
+pre.code span.method { color: #008B8B; }
+pre.code span.module { color: #A020F0; font-weight: bold; }
+pre.code span.number { color: #DD00DD; }
+pre.code span.punct { color: #6A5ACD; }
+pre.code span.regex { color: #DD00DD; }
+pre.code span.string { color: #DD00DD; }
+pre.code span.symbol { color: #008B8B; }
+END_CSS
+  end
+
+  def svg_javascript
+    return <<END_JS
+<script type='text/javascript'>
+  <![CDATA[
+
+var windows = new Array()
+var info = new Array()
+
+function openWin(target, time) {
+  win = window.open(target + \"_\" + time + \".html\", target, \"location=no,width=400,height=180,left=0,status=no\");
+  // hm, an associative array, how strange.
+  info[target] = 1
+}
+
+function advanceTo(time) {
+  arr = gup(\"wins\").split(\",\");
+  for (i=0; i < arr.length; i++) {
+    if (arr[i] != \"\") {
+      openWin(arr[i], time);
+    }
+  }
+  str = '';
+  // getting 'key_cols'
+  for (var i in info) {
+    str = str + ',' + i;
+  }
+  self.window.location.href = 'tm_' + time + '.svg?wins=' + str;
+}
+
+// off the netz
+function gup(name) {
+  name = name.replace(/[\[]/,\"\\\[\").replace(/[\]]/,\"\\\]\");
+  var regexS = \"[\\?&]\"+name+\"=([^&#]*)\";
+  var regex = new RegExp(regexS);
+  var results = regex.exec(window.location.href);
+  if (results == null)
+    return \"\";
+  else
+    return results[1];
+}
+
+  ]]>
+</script>
+END_JS
+  end
+
+  def get_meta2(dir)
+    meta_tabs = {"t_table_info" => :tabinf, "t_table_schema" => :tabscm, "t_cycle" => :cycle, "t_depends" => :depends, "t_rules" => :rules}
+    meta = {}
+    data = []
+    ret = DBM.open("#{dir}/the_big_log.dbm")
+    ret.each_pair do |k, v|
+      key = MessagePack.unpack(k)
+      tab = key.shift
+      time = key.shift
+      # paa
+      tup = key[0]
+      MessagePack.unpack(v).each {|val| tup << val}
+      if meta_tabs[tab]
+        raise "non-zero budtime.  sure this is metadata?" if time != 0 and strict
+        meta[meta_tabs[tab]] ||= []
+        meta[meta_tabs[tab]] << tup
+        #ret << tup
+      else
+        data << [time, tab, tup]
+      end
+    end
+    
+    meta_tabs.each_value do |tab|
+      meta[tab] ||= [] 
+    end
+
+    meta[:schminf] = {}
+    meta[:tabscm].each do |ts|
+      tab = ts[0].to_s
+      unless meta[:schminf][tab]
+        meta[:schminf][tab] = []
+      end
+      meta[:schminf][tab][ts[2]] = ts[1]
+    end
+    return meta, data
+  end
+end