zillabyte 0.0.6

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

@@ -0,0 +1,90 @@
+require 'optparse'
+
+class Zillabyte::Harness::SimpleSpout
+  attr_accessor :_nodes, :_sink, :_name  
+
+
+  def self.build()
+
+    # Parse the options... 
+    options = Zillabyte::Harness::Helper.opt_parser()
+    flow = Zillabyte::Harness::SimpleSpout.new()
+    flow._nodes = []
+    flow._name = options[:name]
+
+    # Get the user logic... 
+    yield(flow)
+    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 spout-specific logic... 
+    spout = Zillabyte::Harness::Spout.new(false)
+    yield(spout)
+    spout._name = "spout"
+    flow._nodes << spout
+    if(options[:command] == :info)
+      info_hash = {"name" => spout._name, "type" => spout._type}
+      if(spout._emits)
+        info_hash["emits"] = spout._emits
+      elsif(spout._relation)
+        info_hash["relation"] = spout._relation
+      elsif(spout._matches)
+        info_hash["matches"] = spout._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}
+      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, _info_file)
+    end
+    
+    # Execute...
+    if(options[:command] == :execute and options[:name] == "spout")
+      pipe_name = options[:pipe]
+      c = Zillabyte::Harness::SpoutController.new(spout, progress = Zillabyte::Common::Progress.new)
+      c.run(pipe_name)
+    end
+    
+    # Done
+    flow
+  end
+
+
+
+  def name(v)
+    Zillabyte::Harness::Helper.check_name("simple_spout", v, {})
+    @_name = v
+  end
+
+
+  def emits(v)
+    # Construct the sink...
+    Zillabyte::Harness::Helper.check_emits("simple_spout", v, {})
+    @_sink = Zillabyte::Harness::Sink.new()
+    @_sink.name(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/sink.rb

@@ -0,0 +1,23 @@
+class Zillabyte::Harness::Sink
+  attr_accessor :_name, :_type, :_columns, :_consumes
+
+  def initialize()
+    @_type = 'sink'
+    @_columns = []
+  end
+  
+  
+  def consumes(v)
+    @_consumes = v
+  end
+  
+  def name(v)
+    @_name = v
+  end
+  
+  def column(cname, ctype)
+    col = {cname => ctype}
+    @_columns << col
+  end
+  
+end

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

@@ -0,0 +1,48 @@
+class Zillabyte::Harness::Spout
+  attr_accessor :_name, :_type, :_matches, :_relation, :_emits, :_prepare, :_next_batch, :_flow_flag
+
+  def initialize(flow_flag)
+    @_name = "spout_"+Zillabyte::Harness::Counter.get()
+    @_type = 'spout'
+    @_flow_flag = flow_flag
+  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 name(v)
+    @_name = v
+  end
+
+  def emits(v)
+    if(@_flow_flag)
+      @_emits = v
+    else
+      @_emits = []
+      v.each do |relation|
+        temit = []
+        relation[1].each do |column|
+          column.each do |col, type|
+            temit << col
+          end
+        end
+        @_emits << [relation[0], temit]
+      end
+    end
+  end
+
+  def prepare(&block)
+    @_prepare = block
+  end
+
+  def next_batch(&block)
+    @_next_batch = block
+  end
+
+end

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

@@ -0,0 +1,132 @@
+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 || Dir.pwd.split("/")[-1]
+    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 spout_from_relation()
+    h = Zillabyte::Harness::Spout.new(true)
+    yield(h)
+    Zillabyte::Harness::Helper.check_name("spout", h._name, @_names)
+    @_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 spout
+    h = Zillabyte::Harness::Spout.new(true)
+    yield(h)
+    Zillabyte::Harness::Helper.check_name("spout", h._name, @_names)
+    @_branched = Zillabyte::Harness::Helper.check_emits("spout", h._emits, @_streams) || @_branched
+    @_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)
+    elsif(@_options[:command] == :execute and @_options[:name] == h._name)
+      pipe_name = @_options[:pipe]
+      c = Zillabyte::Harness::SpoutController.new(h, progress = Zillabyte::Common::Progress.new)
+      c.run(pipe_name)
+    end
+  end
+
+  def each
+    h = Zillabyte::Harness::Each.new()
+    yield(h)
+    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 group_by(fields)
+    h = Zillabyte::Harness::GroupBy.new(fields)
+    @_nodes << h
+  end
+
+  def aggregate
+    h = Zillabyte::Harness::Aggregate.new()
+    yield(h)
+    Zillabyte::Harness::Helper.check_name("aggregate", h._name, @_names)
+    @_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, "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+"_start")
+        c = Zillabyte::Harness::AggregateStartController.new(h, Zillabyte::Common::Progress.new)
+      elsif(@_options[:name] == h._name+"_aggregate")
+        c = Zillabyte::Harness::AggregateAggregateController.new(h, Zillabyte::Common::Progress.new)
+      elsif(@_options[:name] == h._name+"_complete")
+        c = Zillabyte::Harness::AggregateCompleteController.new(h, Zillabyte::Common::Progress.new)
+      end
+      c.run(pipe_name)
+    end
+  end
+
+  def sink
+    h = Zillabyte::Harness::Sink.new()
+    yield(h)
+    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}
+      if(h._consumes)
+        info_hash["consumes"] = h._consumes
+      end
+      Zillabyte::Harness::Helper.write_hash_to_file(info_hash, @_info_file)
+    end
+  end
+  
+end

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

@@ -0,0 +1,32 @@
+class Tuple
+  attr_accessor :id, :component, :stream, :task, :values, :fields
+
+  def initialize(hash)
+    @hash = hash    
+  end
+  
+  def [](k)
+    values[k]
+  end
+  
+  def values
+    @hash["tuple"]
+  end
+  
+  
+  def self.from_hash(hash)
+    begin
+      t = hash.fetch("tuple")
+    rescue Exception => e
+      fail 'Missing tuple field in emitted JSON object' + e.backtrace.join('\n')
+      return nil
+    end
+    begin
+      m = hash.fetch("meta")
+    rescue Exception => e
+      fail 'Missing meta field in emitted JSON object' + e.backtrace.join('\n')
+      return nil
+    end
+    Tuple.new(hash)
+  end
+end

data/ruby/lib/zillabyte/version.rb

@@ -0,0 +1,3 @@
+module Zillabyte
+  VERSION = "0.0.6" unless defined?(VERSION)
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: zillabyte
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- zillabyte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zillabyte-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Official Zillabyte Gem
+email:
+- gem@zillabyte.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ruby/lib/zillabyte/common/progress.rb
+- ruby/lib/zillabyte/harness/aggregate.rb
+- ruby/lib/zillabyte/harness/counter.rb
+- ruby/lib/zillabyte/harness/each.rb
+- ruby/lib/zillabyte/harness/groupby.rb
+- ruby/lib/zillabyte/harness/helper.rb
+- ruby/lib/zillabyte/harness/live_delegator.rb
+- ruby/lib/zillabyte/harness/simple_function.rb
+- ruby/lib/zillabyte/harness/simple_spout.rb
+- ruby/lib/zillabyte/harness/sink.rb
+- ruby/lib/zillabyte/harness/spout.rb
+- ruby/lib/zillabyte/harness/topology.rb
+- ruby/lib/zillabyte/harness/tuple.rb
+- ruby/lib/zillabyte/harness.rb
+- ruby/lib/zillabyte/version.rb
+- ruby/lib/zillabyte.rb
+- ruby/README.md
+homepage: http://www.zillabyte.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ruby/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: The Official Zillabyte Gem
+test_files: []