zillabyte 0.0.16 → 0.0.17

data/ruby/lib/zillabyte/harness/simple_function.rb

@@ -1,134 +0,0 @@
-require 'optparse'
-
-class Zillabyte::Harness::SimpleFunction
-  attr_accessor :_nodes, :_relation, :_matches, :_emits, :_prepare, :_execute, :_name, :_info_file, :_options
-
-  def self.build(*args, &block)
-    h = Zillabyte::Harness::SimpleFunction.new()
-    h.instance_eval(&block)
-    #yield(h)
-    h._name = h._name
-    Zillabyte::Harness::Helper.check_name("simple_function", h._name, {})
-    Zillabyte::Harness::Helper.check_emits("simple_function", h._emits, {})
-    generic_emits = h.get_generic_emits
-    
-    h._nodes = []
-    h._options = Zillabyte::Harness::Helper.opt_parser()
-
-    if(h._options[:command] == :info)
-      h._info_file = File.open(h._options[:file],"w+")
-      hash = {"language" => "ruby", "name" => h._name}
-      Zillabyte::Harness::Helper.write_hash_to_file(hash, h._info_file)
-    end
-
-    h.build_source()
-    fn = h.build_each(generic_emits)
-    h.build_sink()   
-
-    if(h._options[:command] == :execute and h._options[:name] == 'each')
-      pipe_name = h._options[:pipe]
-      c = Zillabyte::Harness::EachController.new(fn, progress = Zillabyte::Common::Progress.new)
-      c.run(pipe_name)
-    end
-
-    h
-  end
-
-  def name(v)
-    @_name = v
-  end
-
-  def matches(v, options = {})
-    case v
-    when String
-      @_relation = { :query => v, :options => options.is_a?(Hash) ? options : {} }
-    when Array
-      @_matches = v
-    end
-  end
-
-  def emits(v)
-    @_emits = v
-  end
-  
-  def prepare(&block)
-    @_prepare = block
-  end
-
-  def execute(&block)
-    @_execute = block
-  end
-  
-  def get_generic_emits()
-    generic_emits = []
-    @_emits.each do |relation|
-      temit = []
-      relation[1].each do |column|
-        column.each do |col, type|
-          temit << col
-        end
-      end
-      generic_emits << [relation[0], temit]
-    end
-    generic_emits
-  end
-
-  def build_source()
-    h = Zillabyte::Harness::Source.new(false)
-    h._matches = @_matches if @_matches
-    h._relation = @_relation if @_relation
-    Zillabyte::Harness::Helper.check_source("simple_function", h)
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type}
-      if(h._relation)
-        info_hash["relation"] = h._relation
-      elsif(h._matches)
-        info_hash["matches"] = h._matches
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    end
-  end
-
-  def build_each(generic_emits)
-    h = Zillabyte::Harness::Each.new()
-    h._name = 'each'
-    h._emits = generic_emits
-    h._prepare = @_prepare
-    h._execute = @_execute
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type, "emits" => h._emits}
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    end
-    h
-  end
-
-  def build_sink()
-    # Construct the sink...
-    n_sinks = @_emits.length
-    @_emits.each do |emit|
-      h = Zillabyte::Harness::Sink.new()
-      h._name = "sink"
-      h._relation = emit[0]
-      columns = emit[1]
-      columns.each do |col|
-        col.each do |cname, ctype|
-          h.column(cname, ctype)
-        end
-      end
-      if(n_sinks > 1)
-        h._consumes = h._name
-      end
-      @_nodes << h
-      if(@_options[:command] == :info)
-        info_hash = {"name" => h._name, "type" => h._type, "columns" => h._columns, "relation" => h._relation || h._name}
-        if(h._consumes)
-          info_hash["consumes"] = h._consumes
-        end
-        Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-      end
-    end
-  end
-
-end

data/ruby/lib/zillabyte/harness/simple_source.rb

@@ -1,93 +0,0 @@
-require 'optparse'
-
-class Zillabyte::Harness::SimpleSource
-  attr_accessor :_nodes, :_sink, :_name  
-
-  def self.build(*args, &block)
-
-    # Parse the options... 
-    options = Zillabyte::Harness::Helper.opt_parser()
-    flow = Zillabyte::Harness::SimpleSource.new()
-    flow._nodes = []
-    flow._name = options[:name]
-
-    # Get the user logic... 
-    #yield(flow)
-    flow.instance_eval(&block)
-    if(options[:command] == :info)
-      _info_file = File.open(options[:file], "w+")
-      info_hash = {"language" => "ruby", "name" => flow._name}
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, _info_file)
-    end
-    
-    # Get the source-specific logic... 
-    source = Zillabyte::Harness::Source.new(false)
-    #yield(source)
-    source.instance_eval(&block)
-    source._name = "source"
-    Zillabyte::Harness::Helper.check_source("simple_source", source)
-    flow._nodes << source
-    if(options[:command] == :info)
-      info_hash = {"name" => source._name, "type" => source._type}
-      if(source._emits)
-        info_hash["emits"] = source._emits
-      elsif(source._relation)
-        info_hash["relation"] = source._relation
-      elsif(source._matches)
-        info_hash["matches"] = source._matches
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, _info_file)
-    end
-
-    # Add the sink... 
-    flow._nodes << flow._sink
-    if(options[:command] == :info)
-      info_hash = {"name" => flow._sink._name, "type" => flow._sink._type, "columns" => flow._sink._columns, "relation" => flow._sink._relation || flow._sink._name}
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, _info_file)
-    end
-    
-    # Execute...
-    if(options[:command] == :execute and options[:name] == "source")
-      pipe_name = options[:pipe]
-      c = Zillabyte::Harness::SourceController.new(source, progress = Zillabyte::Common::Progress.new)
-      c.run(pipe_name)
-    end
-    
-    # Done
-    flow
-  end
-
-
-
-  def name(v)
-    Zillabyte::Harness::Helper.check_name("simple_source", v, {})
-    @_name = v
-  end
-
-
-  def emits(v)
-    # Construct the sink...
-    Zillabyte::Harness::Helper.check_emits("simple_source", v, {})
-    @_sink = Zillabyte::Harness::Sink.new()
-    @_sink._name = "sink"
-    @_sink._relation = v[0][0] 
-    columns = v[0][1]
-    columns.each do |col|
-      col.each do |cname, ctype|
-        @_sink.column(cname, ctype)
-      end
-    end
-  end
-
-
-  def prepare(&block)
-    # Dummy function, prepare is picked up by Each above
-  end
-
-  def next_batch(&block)
-    # Dummy function, execute is picked up by Each above
-  end
-  
-  
-end
-

data/ruby/lib/zillabyte/harness/topology.rb

@@ -1,127 +0,0 @@
-require "json"
-
-class Zillabyte::Harness::Topology
-  attr_accessor :_name, :_options, :_nodes, :_streams, :_names, :_branched, :_info_file #instance variables?
-
-  def self.build(name)
-    h = Zillabyte::Harness::Topology.new()
-    h._nodes = []
-    h._streams = {}
-    h._names = {}
-    h._branched = false
-    h._name = name
-    Zillabyte::Harness::Helper.check_name("new", h._name, {})
-    h._options = Zillabyte::Harness::Helper.opt_parser()
-    if(h._options[:command] == :info)
-      h._info_file = File.open(h._options[:file],"w+")
-      info_hash = {"language" => "ruby", "name" => h._name}
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, h._info_file)
-    end
-    h
-  end
-
-  def source(&block)
-    h = Zillabyte::Harness::Source.new(true)
-    #yield(h)
-    h.instance_eval(&block)
-    Zillabyte::Harness::Helper.check_name("source", h._name, @_names)
-    Zillabyte::Harness::Helper.check_source("source", h)
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type}
-      if(h._relation)
-        info_hash["relation"] = h._relation
-      elsif(h._matches)
-        info_hash["matches"] = h._matches
-      elsif(h._emits)
-        @_branched = Zillabyte::Harness::Helper.check_emits("source", h._emits, @_streams) || @_branched
-        info_hash["emits"] = h._emits
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    elsif(@_options[:command] == :execute and @_options[:name] == h._name)
-      pipe_name = @_options[:pipe]
-      c = Zillabyte::Harness::SourceController.new(h, progress = Zillabyte::Common::Progress.new)
-      c.run(pipe_name)
-    end
-  end
-
-  def each(&block)
-    h = Zillabyte::Harness::Each.new()
-    #yield(h)
-    h.instance_eval(&block)
-    Zillabyte::Harness::Helper.check_name("each", h._name, @_names)
-    if(@_branched)
-      Zillabyte::Harness::Helper.check_consumes(h, @_streams)
-    else
-      if(h._consumes)
-        h._consumes = nil
-      end
-    end
-    @_branched = Zillabyte::Harness::Helper.check_emits("each", h._emits, @_streams) || @_branched
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type, "emits" => h._emits}
-      if(h._consumes)
-        info_hash["consumes"] = h._consumes
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    elsif(@_options[:command] == :execute and @_options[:name] == h._name)
-      pipe_name = @_options[:pipe]
-      c = Zillabyte::Harness::EachController.new(h, progress = Zillabyte::Common::Progress.new)
-      c.run(pipe_name)
-    end
-  end
-
-  def aggregate(&block)
-    h = Zillabyte::Harness::Aggregate.new()
-    #yield(h)
-    h.instance_eval(&block)
-    Zillabyte::Harness::Helper.check_name("aggregate", h._name, @_names)
-    if(@_branched)
-      Zillabyte::Harness::Helper.check_consumes(h, @_streams)
-    else
-      if(h._consumes)
-        h._consumes = nil
-      end
-    end
-    Zillabyte::Harness::Helper.check_group_by("aggregate", h, @_nodes, @_streams)
-    @_branched = Zillabyte::Harness::Helper.check_emits("aggregate", h._emits, @_streams) || @_branched
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type, "group_by" => h._group_by, "emits" => h._emits}
-      if(h._consumes)
-        info_hash["consumes"] = h._consumes
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    elsif(@_options[:command] == :execute)
-      pipe_name = @_options[:pipe]
-      if(@_options[:name] == h._name)
-        c = Zillabyte::Harness::AggregateController.new(h, Zillabyte::Common::Progress.new)
-        c.run(pipe_name)
-      end
-    end
-  end
-
-  def sink(&block)
-    h = Zillabyte::Harness::Sink.new()
-    #yield(h)
-    h.instance_eval(&block)
-    Zillabyte::Harness::Helper.check_sink(h, @_nodes)
-    if(@_branched)
-      Zillabyte::Harness::Helper.check_consumes(h, @_streams)
-    else
-      if(h._consumes)
-        h._consumes = nil
-      end
-    end
-    @_nodes << h
-    if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type, "columns" => h._columns, "relation" => h._relation || h._name}
-      if(h._consumes)
-        info_hash["consumes"] = h._consumes
-      end
-      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
-    end
-  end
-  
-end