zillabyte 0.0.15 → 0.0.16

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDMxZjc1NTM0YTg0OWQyMGQ0NDI4N2NkM2U5NzViYjlkOTU2NGY3OA==
+    OTIzYmY3MjJhM2U0M2I2OGU4ZGE3ZDk2YmI4NjhkYzM1MTY0ZjY1ZA==
   data.tar.gz: !binary |-
-    Y2Q5NGQ2N2RkZDhiNmU0MGYxOGU2ZDQ0ZjEzYWVkMDVmOTc4N2EwMA==
-SHA512:
+    OTkyMzYzODhjZmNmNjZiYzc2ZGI3NTVjNDFlNDljMzBjNTJhOTRiOQ==
+!binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MmJmYjA2YmZmOGRmN2FiOTllNDhhNTlmZjkzNzQyYTBlZWY0NDU0OWQyNTBl
-    N2JlN2RlN2Y5YTA1NzAyZjM2NDQzMjg2MGZlZjM0M2QzZTFkYzgxZDI2ZDMw
-    N2ZmODdjZTQzYzJmOGI0NzQzNmNhMTc3MDAzNmQ3YTRkODEwN2I=
+    OTJiZjQwMGRiYjEzMTM4YTZlODZhZTA2N2Y1YjNiMDQ4MTY3NWNkZjNkYzM0
+    NzRkNmVkN2M3OTFmNjc1Yzc2ZDU5YTA5ZjNlODU3YjIwNzVlNTE1NGM5OTk5
+    YjQxOThlNWNmY2E0YWUwM2YzZjM4Y2JhMzY3Y2IyM2VkMjM0ZTQ=
   data.tar.gz: !binary |-
-    ODVmZTViMTUzZTRkYTkwMzJkMzhmYjVhN2RhZjE0MDgyZjg1ZmM2ZjFiOGY0
-    OGQ3MzU1ZTBhOTcwMDY0YTY3YjNjOTM4NjM0Yjc3MTNmMWQ0ODFjMTg3MjQ2
-    YWIxYmZkZTQzMDE5NTI4NzNkZjI4Y2UxM2E3NmI4ZGQwYmIxNTg=
+    N2IyMjlhMWVkZTdmODA4MmZhOWY4YTU0NTg3NDMwZTlhY2ZmOTMzZjAyNzU1
+    Y2E0ZTcxYzYyNmVjM2Q0ZDM5YjEyMmQ1Y2ZlOGJmY2NmZjk2MDRiMzQ1ODIx
+    OGUyOWY4MmRmODc4M2VkMTJiOWI5ZTY0MTVjYTZiYWM4MjE5MjQ=

data/ruby/lib/zillabyte.rb

@@ -12,8 +12,8 @@ module Zillabyte
     Zillabyte::Harness::SimpleFunction.build(*args, &block)
   end
 
-  def self.simple_spout(*args, &block)
-    Zillabyte::Harness::SimpleSpout.build(*args, &block)
+  def self.simple_source(*args, &block)
+    Zillabyte::Harness::SimpleSource.build(*args, &block)
   end
 
   def self.simple_aggregate(*args, &block)

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

@@ -49,6 +49,29 @@ class Zillabyte::Harness::Helper
 
   end
 
+  def self.check_source(operation, source)
+    ee = "Error in \"#{operation}\": \n\t "
+    if(["simple_function", "simple_aggregate"].member?(operation))
+      pp = "\"#{operation}\" may only contain a single \"matches\" clause."
+    else
+      pp = "A \"#{operation}\" may only contain a single \"emits\" OR \"matches\" clause."
+    end
+
+    em = !source._emits.nil?
+    rm = !source._relation.nil?
+    mm = !source._matches.nil?
+    if( (em and rm) or (rm and mm) or (mm and em) )
+      msg = "#{ee}#{pp}"
+      Zillabyte::Harness::Helper.print_error(msg)
+    end
+    if(rm or mm)
+      if source._prepare or source._next_batch
+        msg = "#{ee}If \"#{operation}\" has a \"matches\" clause, it may not have a \"prepare\" or \"next_batch\" block."
+        Zillabyte::Harness::Helper.print_error(msg)
+      end
+    end
+  end
+
   def self.check_emits(operation, emits, streams)
     ee = "Error in \"#{operation}\" at \"emits\": \n\t "
     if(operation.include?("simple"))
@@ -133,7 +156,7 @@ class Zillabyte::Harness::Helper
 
     consumes = h._consumes
     if(!consumes)
-      msg = "#{ee}\"Consumes\" must be specified since a preceding \"each\", \"spout\" or \"aggregate\" emitted multiple streams. #{pp}"
+      msg = "#{ee}\"Consumes\" must be specified since a preceding \"each\", \"source\" or \"aggregate\" emitted multiple streams. #{pp}"
       Zillabyte::Harness::Helper.print_error(msg)
     end
     if(!streams[consumes])
@@ -160,7 +183,7 @@ class Zillabyte::Harness::Helper
     end
 
     if(operation == "aggregate")
-# Can't check group_by fields for simple_aggregate because "matches" does not specify emitted fields from spout!
+# Can't check group_by fields for simple_aggregate because "matches" does not specify emitted fields from source!
       group_by.each do |f|
         if(h._consumes)
           fields = streams[h._consumes]
@@ -357,7 +380,7 @@ consumed by the aggregation function."
  - Field names cannot be \"v[number]\", \"id\", \"confidence\", \"since\" or \"source\" which are reserved Zillabyte names.
  - Field types must be SYMBOLS. The following types are allowed :string, :integer, :float, :double, and :boolean.
  - If there are multiple streams, \"consumes\" must be specified for each sink as a non-empty STRING!
-     * \"Consumes\" is the name of a stream emitted by an \"each\" or a \"spout\" which the \"sink\" should save as a table.
+     * \"Consumes\" is the name of a stream emitted by an \"each\" or a \"source\" which the \"sink\" should save as a table.
      * The columns specified in \"sink\" must match the fields emitted by the stream."
 
   @@_print_check_each_consumes = "\n
@@ -370,7 +393,7 @@ consumed by the aggregation function."
  \t \t h.execute ...
  \t end
  - If there are multiple streams, \"consumes\" must be specified as a non-empty STRING!
-     * \"Consumes\" is the name of a stream emitted by a preceding \"each\", \"spout\" or \"aggregate\" which the current \"each\" operates on."
+     * \"Consumes\" is the name of a stream emitted by a preceding \"each\", \"source\" or \"aggregate\" which the current \"each\" operates on."
 
   @@_print_check_aggregate_consumes = "\n
 \"Aggregate\" Syntax for multiple streams:
@@ -384,7 +407,7 @@ consumed by the aggregation function."
  \t \t h.end_group ...
  \t end
  - If there are multiple streams, \"consumes\" must be specified as a non-empty STRING!
-     * \"Consumes\" is the name of a stream emitted by a preceding \"each\", \"spout\" or \"aggregate\" which the current \"aggregate\" operates on."
+     * \"Consumes\" is the name of a stream emitted by a preceding \"each\", \"source\" or \"aggregate\" which the current \"aggregate\" operates on."
 
   @@meta_names=["id", "confidence", "since", "source"]
 end

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

@@ -122,7 +122,7 @@ module Zillabyte
     end
 
 
-    class Spout
+    class Source
       include Storm::Protocol
 
       def open(conf, context); end
@@ -132,7 +132,7 @@ module Zillabyte
       def ack(id); end
 
       def run(pipe_name)
-        Storm::Protocol.mode = 'spout'
+        Storm::Protocol.mode = 'source'
         Storm::Protocol.pipe_name = pipe_name
         setup_pipes
         open(*handshake)
@@ -151,7 +151,7 @@ module Zillabyte
           rescue SignalException => e
             raise
           rescue Exception => e
-            fail 'Exception in spout: ' + e.message + ' - ' + e.backtrace.join('\n')
+            fail 'Exception in source: ' + e.message + ' - ' + e.backtrace.join('\n')
             break
           end
           done
@@ -224,7 +224,7 @@ module Zillabyte
 
   module Harness
 
-    class SpoutController < Storm::Spout
+    class SourceController < Storm::Source
 
       def initialize(harness, progress)
         @harness = harness
@@ -232,11 +232,15 @@ module Zillabyte
       end
 
       def open(*args)
-        @harness._prepare.call(self, *args) if @harness._prepare
+        self.instance_exec(*args, &@harness._prepare) if @harness._prepare
+        #@harness._prepare.call(self, *args) if @harness._prepare
       end
 
       def next_batch
-        @harness._next_batch.call(self)
+        #@harness._next_batch.call(self)
+        # Executes the block @harness._next_batch in the context of the class self (i.e. exposes all methods of self to
+        # the block).
+        self.instance_eval &@harness._next_batch
       end
 
     end
@@ -249,11 +253,15 @@ module Zillabyte
       end
 
       def execute(*args)
-        @harness._execute.call(self, *args)
+        #@harness._execute.call(self, *args)
+        # Executes the block @harness._next_batch in the context of the class self (i.e. exposes all methods of self to
+        # the block). Also allows you to pass in arguments to the block in *args.
+        self.instance_exec *args, &@harness._execute
       end
 
       def prepare(*args)
-        @harness._prepare.call(self, *args) if @harness._prepare
+        self.instance_exec(*args, &@harness._prepare) if @harness._prepare
+        #@harness._prepare.call(self, *args) if @harness._prepare
       end
 
     end
@@ -266,15 +274,18 @@ module Zillabyte
       end
 
       def begin_group(*args)
-        @harness._begin_group.call(*args)
+        #@harness._begin_group.call(*args)
+        self.instance_exec *args, &@harness._begin_group
       end
 
       def aggregate(*args)
-        @harness._aggregate.call(*args)
+        #@harness._aggregate.call(*args)
+        self.instance_exec *args, &@harness._aggregate
       end
 
       def end_group(*args)
-        @harness._end_group.call(self, *args)
+        #@harness._end_group.call(self, *args)
+        self.instance_exec *args, &@harness._end_group
       end
 
     end

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

@@ -3,9 +3,10 @@ require 'optparse'
 class Zillabyte::Harness::SimpleAggregate
   attr_accessor :_nodes, :_relation, :_matches, :_group_by, :_emits, :_begin_group, :_aggregate, :_end_group, :_name, :_info_file, :_options
 
-  def self.build()
+  def self.build(*args, &block)
     h = Zillabyte::Harness::SimpleAggregate.new()
-    yield(h)
+    #yield(h)
+    h.instance_eval(&block)
     h._name = h._name
     Zillabyte::Harness::Helper.check_name("simple_aggregate", h._name, {})
     Zillabyte::Harness::Helper.check_emits("simple_aggregate", h._emits, {})
@@ -20,7 +21,7 @@ class Zillabyte::Harness::SimpleAggregate
       Zillabyte::Harness::Helper.write_hash_to_file(hash, h._info_file)
     end
 
-    h.build_spout()
+    h.build_source()
     fn = h.build_aggregate(generic_emits)
     h.build_sink()   
 
@@ -80,10 +81,11 @@ class Zillabyte::Harness::SimpleAggregate
     generic_emits
   end
 
-  def build_spout()
-    h = Zillabyte::Harness::Spout.new(false)
+  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_aggregate", h)
     @_nodes << h
     if(@_options[:command] == :info)
       info_hash = {"name" => h._name, "type" => h._type}
@@ -130,7 +132,7 @@ class Zillabyte::Harness::SimpleAggregate
       end
       @_nodes << h
       if(@_options[:command] == :info)
-        info_hash = {"name" => h._name, "type" => h._type, "columns" => h._columns}
+        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

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

@@ -3,9 +3,10 @@ require 'optparse'
 class Zillabyte::Harness::SimpleFunction
   attr_accessor :_nodes, :_relation, :_matches, :_emits, :_prepare, :_execute, :_name, :_info_file, :_options
 
-  def self.build()
+  def self.build(*args, &block)
     h = Zillabyte::Harness::SimpleFunction.new()
-    yield(h)
+    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, {})
@@ -20,11 +21,11 @@ class Zillabyte::Harness::SimpleFunction
       Zillabyte::Harness::Helper.write_hash_to_file(hash, h._info_file)
     end
 
-    h.build_spout()
+    h.build_source()
     fn = h.build_each(generic_emits)
     h.build_sink()   
 
-    if(h._options[:command] == :execute and h._options[:name] == h._name)
+    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)
@@ -72,10 +73,11 @@ class Zillabyte::Harness::SimpleFunction
     generic_emits
   end
 
-  def build_spout()
-    h = Zillabyte::Harness::Spout.new(false)
+  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}
@@ -90,7 +92,7 @@ class Zillabyte::Harness::SimpleFunction
 
   def build_each(generic_emits)
     h = Zillabyte::Harness::Each.new()
-    h._name = @_name
+    h._name = 'each'
     h._emits = generic_emits
     h._prepare = @_prepare
     h._execute = @_execute
@@ -107,7 +109,8 @@ class Zillabyte::Harness::SimpleFunction
     n_sinks = @_emits.length
     @_emits.each do |emit|
       h = Zillabyte::Harness::Sink.new()
-      h._name = emit[0]
+      h._name = "sink"
+      h._relation = emit[0]
       columns = emit[1]
       columns.each do |col|
         col.each do |cname, ctype|
@@ -119,7 +122,7 @@ class Zillabyte::Harness::SimpleFunction
       end
       @_nodes << h
       if(@_options[:command] == :info)
-        info_hash = {"name" => h._name, "type" => h._type, "columns" => h._columns}
+        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

data/ruby/lib/zillabyte/harness/{simple_spout.rb → simple_source.rb}

@@ -1,38 +1,40 @@
 require 'optparse'
 
-class Zillabyte::Harness::SimpleSpout
+class Zillabyte::Harness::SimpleSource
   attr_accessor :_nodes, :_sink, :_name  
 
-
-  def self.build()
+  def self.build(*args, &block)
 
     # Parse the options... 
     options = Zillabyte::Harness::Helper.opt_parser()
-    flow = Zillabyte::Harness::SimpleSpout.new()
+    flow = Zillabyte::Harness::SimpleSource.new()
     flow._nodes = []
     flow._name = options[:name]
 
     # Get the user logic... 
-    yield(flow)
+    #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 spout-specific logic... 
-    spout = Zillabyte::Harness::Spout.new(false)
-    yield(spout)
-    spout._name = "spout"
-    flow._nodes << spout
+    # 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" => 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
+      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
@@ -40,14 +42,14 @@ class Zillabyte::Harness::SimpleSpout
     # 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}
+      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] == "spout")
+    if(options[:command] == :execute and options[:name] == "source")
       pipe_name = options[:pipe]
-      c = Zillabyte::Harness::SpoutController.new(spout, progress = Zillabyte::Common::Progress.new)
+      c = Zillabyte::Harness::SourceController.new(source, progress = Zillabyte::Common::Progress.new)
       c.run(pipe_name)
     end
     
@@ -58,16 +60,17 @@ class Zillabyte::Harness::SimpleSpout
 
 
   def name(v)
-    Zillabyte::Harness::Helper.check_name("simple_spout", v, {})
+    Zillabyte::Harness::Helper.check_name("simple_source", v, {})
     @_name = v
   end
 
 
   def emits(v)
     # Construct the sink...
-    Zillabyte::Harness::Helper.check_emits("simple_spout", v, {})
+    Zillabyte::Harness::Helper.check_emits("simple_source", v, {})
     @_sink = Zillabyte::Harness::Sink.new()
-    @_sink.name(v[0][0])
+    @_sink._name = "sink"
+    @_sink._relation = v[0][0] 
     columns = v[0][1]
     columns.each do |col|
       col.each do |cname, ctype|

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

@@ -1,5 +1,5 @@
 class Zillabyte::Harness::Sink
-  attr_accessor :_name, :_type, :_columns, :_consumes
+  attr_accessor :_name, :_relation, :_type, :_columns, :_consumes
 
   def initialize()
     @_type = 'sink'
@@ -15,6 +15,10 @@ class Zillabyte::Harness::Sink
     @_name = v
   end
   
+  def relation(v)
+    @_relation = v
+  end
+  
   def column(cname, ctype)
     col = {cname => ctype}
     @_columns << col

data/ruby/lib/zillabyte/harness/{spout.rb → source.rb}

@@ -1,9 +1,9 @@
-class Zillabyte::Harness::Spout
+class Zillabyte::Harness::Source
   attr_accessor :_name, :_type, :_matches, :_relation, :_emits, :_prepare, :_next_batch, :_flow_flag
 
   def initialize(flow_flag)
-    @_name = "spout_"+Zillabyte::Harness::Counter.get()
-    @_type = 'spout'
+    @_name = "source_"+Zillabyte::Harness::Counter.get()
+    @_type = 'source'
     @_flow_flag = flow_flag
   end
 

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

@@ -20,10 +20,12 @@ class Zillabyte::Harness::Topology
     h
   end
 
-  def spout_from_relation()
-    h = Zillabyte::Harness::Spout.new(true)
-    yield(h)
-    Zillabyte::Harness::Helper.check_name("spout", h._name, @_names)
+  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}
@@ -31,30 +33,22 @@ class Zillabyte::Harness::Topology
         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)
-    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 = Zillabyte::Harness::SourceController.new(h, progress = Zillabyte::Common::Progress.new)
       c.run(pipe_name)
     end
   end
 
-  def each
+  def each(&block)
     h = Zillabyte::Harness::Each.new()
-    yield(h)
+    #yield(h)
+    h.instance_eval(&block)
     Zillabyte::Harness::Helper.check_name("each", h._name, @_names)
     if(@_branched)
       Zillabyte::Harness::Helper.check_consumes(h, @_streams)
@@ -78,9 +72,10 @@ class Zillabyte::Harness::Topology
     end
   end
 
-  def aggregate
+  def aggregate(&block)
     h = Zillabyte::Harness::Aggregate.new()
-    yield(h)
+    #yield(h)
+    h.instance_eval(&block)
     Zillabyte::Harness::Helper.check_name("aggregate", h._name, @_names)
     if(@_branched)
       Zillabyte::Harness::Helper.check_consumes(h, @_streams)
@@ -107,9 +102,10 @@ class Zillabyte::Harness::Topology
     end
   end
 
-  def sink
+  def sink(&block)
     h = Zillabyte::Harness::Sink.new()
-    yield(h)
+    #yield(h)
+    h.instance_eval(&block)
     Zillabyte::Harness::Helper.check_sink(h, @_nodes)
     if(@_branched)
       Zillabyte::Harness::Helper.check_consumes(h, @_streams)
@@ -120,7 +116,7 @@ class Zillabyte::Harness::Topology
     end
     @_nodes << h
     if(@_options[:command] == :info)
-      info_hash = {"name" => h._name, "type" => h._type, "columns" => h._columns}
+      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

data/ruby/lib/zillabyte/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zillabyte
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - zillabyte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -68,9 +68,9 @@ files:
 - ruby/lib/zillabyte/harness/live_delegator.rb
 - ruby/lib/zillabyte/harness/simple_aggregate.rb
 - ruby/lib/zillabyte/harness/simple_function.rb
-- ruby/lib/zillabyte/harness/simple_spout.rb
+- ruby/lib/zillabyte/harness/simple_source.rb
 - ruby/lib/zillabyte/harness/sink.rb
-- ruby/lib/zillabyte/harness/spout.rb
+- ruby/lib/zillabyte/harness/source.rb
 - ruby/lib/zillabyte/harness/topology.rb
 - ruby/lib/zillabyte/harness/tuple.rb
 - ruby/lib/zillabyte/harness.rb
@@ -97,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.0.7
 signing_key: 
 specification_version: 4
 summary: The Official Zillabyte Gem