rflow 1.0.0a2 → 1.0.0a3

data/spec/rflow/configuration_spec.rb

@@ -43,11 +43,11 @@ class RFlow
         Configuration.add_available_data_extension('A::B::C', C = Module.new)
         Configuration.add_available_data_extension('A::B::C::D', D = Module.new)
 
-        Configuration.available_data_extensions['A'].should == [A]
-        Configuration.available_data_extensions['A::B'].should == [A, B]
-        Configuration.available_data_extensions['A::B::C'].should == [A, B, C]
-        Configuration.available_data_extensions['A::B::C::D'].should == [A, B, C, D]
-        Configuration.available_data_extensions['A::B::C::D::E'].should == [A, B, C, D]
+        expect(Configuration.available_data_extensions['A']).to eq([A])
+        expect(Configuration.available_data_extensions['A::B']).to eq([A, B])
+        expect(Configuration.available_data_extensions['A::B::C']).to eq([A, B, C])
+        expect(Configuration.available_data_extensions['A::B::C::D']).to eq([A, B, C, D])
+        expect(Configuration.available_data_extensions['A::B::C::D::E']).to eq([A, B, C, D])
       end
     end
   end

data/spec/rflow/forward_to_input_port_spec.rb

@@ -11,23 +11,15 @@ class RFlow
     let(:dropped_message_connection) { RFlow::MessageCollectingConnection.new }
 
     let(:generator) do
-      config = RFlow::Configuration::Component.new.tap do |c|
-        c.output_ports << RFlow::Configuration::OutputPort.new(name: 'out')
-      end
-      RFlow::Components::GenerateIntegerSequence.new(config).tap do |c|
-        c.configure! config.options
-        c.out.add_connection nil, ForwardToInputPort.new(ruby_proc_filter, 'in', nil)
+      RFlow::Components::GenerateIntegerSequence.new.tap do |c|
+        c.configure!({})
+        c.out.direct_connect ruby_proc_filter.in
       end
     end
 
     let(:ruby_proc_filter) do
-      config = RFlow::Configuration::Component.new.tap do |c|
-        c.input_ports << RFlow::Configuration::InputPort.new(name: 'in')
-        ['filtered', 'dropped'].each {|p| c.output_ports << RFlow::Configuration::OutputPort.new(name: p) }
-        c.options = {'filter_proc_string' => 'message.data.data_object % 2 == 0'}
-      end
-      RFlow::Components::RubyProcFilter.new(config).tap do |c|
-        c.configure! config.options
+      RFlow::Components::RubyProcFilter.new.tap do |c|
+        c.configure! 'filter_proc_string' => 'message.data.data_object % 2 == 0'
         c.filtered.add_connection nil, filtered_message_connection
         c.dropped.add_connection nil, dropped_message_connection
       end
@@ -36,12 +28,12 @@ class RFlow
     def filtered_messages; filtered_message_connection.messages; end
     def dropped_messages; dropped_message_connection.messages; end
 
-    it 'foo' do
+    it 'should forward generated integers to be filtered by the proc filter' do
       5.times { generator.generate }
-      filtered_messages.should have(3).messages
-      filtered_messages.map(&:data).map(&:data_object).should == [0, 2, 4]
-      dropped_messages.should have(2).messages
-      dropped_messages.map(&:data).map(&:data_object).should == [1, 3]
+      expect(filtered_messages).to have(3).messages
+      expect(filtered_messages.map(&:data).map(&:data_object)).to eq([0, 2, 4])
+      expect(dropped_messages).to have(2).messages
+      expect(dropped_messages.map(&:data).map(&:data_object)).to eq([1, 3])
     end
   end
 end

data/spec/rflow/forward_to_output_port_spec.rb

@@ -10,22 +10,15 @@ class RFlow
     let(:message_connection) { RFlow::MessageCollectingConnection.new }
 
     let(:generator) do
-      config = RFlow::Configuration::Component.new.tap do |c|
-        c.output_ports << RFlow::Configuration::OutputPort.new(name: 'out')
-      end
-      RFlow::Components::GenerateIntegerSequence.new(config).tap do |c|
-        c.configure! config.options
-        c.out.add_connection nil, ForwardToOutputPort.new(ruby_proc_filter, 'filtered')
+      RFlow::Components::GenerateIntegerSequence.new.tap do |c|
+        c.configure!({})
+        c.out.direct_connect ruby_proc_filter.filtered
       end
     end
 
     let(:ruby_proc_filter) do
-      config = RFlow::Configuration::Component.new.tap do |c|
-        c.output_ports << RFlow::Configuration::OutputPort.new(name: 'filtered')
-        c.options = {'filter_proc_string' => 'message % 2 == 0'}
-      end
-      RFlow::Components::RubyProcFilter.new(config).tap do |c|
-        c.configure! config.options
+      RFlow::Components::RubyProcFilter.new.tap do |c|
+        c.configure! 'filter_proc_string' => 'message % 2 == 0'
         c.filtered.add_connection nil, message_connection
       end
     end
@@ -34,7 +27,7 @@ class RFlow
 
     it 'should place the messages on the output port, regardless of the filter' do
       5.times { generator.generate }
-      messages.map(&:data).map(&:data_object).should == [0, 1, 2, 3, 4]
+      expect(messages.map(&:data).map(&:data_object)).to eq([0, 1, 2, 3, 4])
     end
   end
 end

data/spec/rflow/logger_spec.rb

@@ -18,10 +18,10 @@ class RFlow
     before(:each) { initialize_logger }
 
     it "should initialize correctly" do
-      File.exist?(log_file_path).should be true
+      expect(File.exist?(log_file_path)).to be true
 
       logger.error "TESTTESTTEST"
-      File.read(log_file_path).should match(/TESTTESTTEST/)
+      expect(File.read(log_file_path)).to match(/TESTTESTTEST/)
 
       logger.close
     end
@@ -29,16 +29,16 @@ class RFlow
     it "should reopen correctly" do
       moved_path = log_file_path + '.old'
 
-      File.exist?(log_file_path).should be true
-      File.exist?(moved_path).should be false
+      expect(File.exist?(log_file_path)).to be true
+      expect(File.exist?(moved_path)).to be false
 
       File.rename log_file_path, moved_path
 
       logger.reopen
 
       logger.error "TESTTESTTEST"
-      File.read(log_file_path).should match(/TESTTESTTEST/)
-      File.read(moved_path).should_not match(/TESTTESTTEST/)
+      expect(File.read(log_file_path)).to match(/TESTTESTTEST/)
+      expect(File.read(moved_path)).not_to match(/TESTTESTTEST/)
 
       logger.close
     end

data/spec/rflow/message/data/raw_spec.rb

@@ -8,7 +8,7 @@ class RFlow
         let(:schema) { Configuration.available_data_types['RFlow::Message::Data::Raw']['avro'] }
 
         it "should load the schema" do
-          schema.should_not be_nil
+          expect(schema).not_to be_nil
         end
 
         it "should encode and decode an object" do
@@ -20,8 +20,8 @@ class RFlow
           expect { decode_avro(schema, encoded) }.to_not raise_error
           decoded = decode_avro(schema, encoded)
 
-          decoded.should == raw
-          decoded['raw'].should == raw['raw']
+          expect(decoded).to eq(raw)
+          expect(decoded['raw']).to eq(raw['raw'])
         end
       end
     end

data/spec/rflow/message_spec.rb

@@ -83,18 +83,18 @@ class RFlow
 
         it "should correctly set the provenance processing events" do
           Message.new('string_type', valid_provenance).provenance[1].tap do |p|
-            p.component_instance_uuid.should == 'uuid'
-            p.started_at.should == Time.xmlschema(valid_xmlschema_time)
-            p.completed_at.should be_nil
-            p.context.should be_nil
+            expect(p.component_instance_uuid).to eq('uuid')
+            expect(p.started_at).to eq(Time.xmlschema(valid_xmlschema_time))
+            expect(p.completed_at).to be_nil
+            expect(p.context).to be_nil
           end
         end
 
         it "should to_hash its provenance correctly" do
-          Message.new('string_type', valid_provenance).provenance.map(&:to_hash).should == [
+          expect(Message.new('string_type', valid_provenance).provenance.map(&:to_hash)).to eq([
             {"component_instance_uuid" => "uuid", "started_at" => nil, "completed_at" => nil, "context" => nil},
             {"component_instance_uuid" => "uuid", "started_at" => valid_xmlschema_time, "completed_at" => nil, "context" => nil},
-            {"component_instance_uuid" => "uuid", "started_at" => valid_xmlschema_time, "completed_at" => valid_xmlschema_time, "context" => "context"}]
+            {"component_instance_uuid" => "uuid", "started_at" => valid_xmlschema_time, "completed_at" => valid_xmlschema_time, "context" => "context"}])
         end
       end
 
@@ -106,8 +106,8 @@ class RFlow
           end
 
           Message.from_avro(message.to_avro).tap do |processed|
-            processed.data.to_avro.should == message.data.to_avro
-            processed.data.data_object.should == message.data.data_object
+            expect(processed.data.to_avro).to eq(message.data.to_avro)
+            expect(processed.data.data_object).to eq(message.data.data_object)
           end
         end
       end
@@ -117,11 +117,11 @@ class RFlow
           module ExtensionModule; def ext_method; end; end
 
           message = Message.new('string_type')
-          message.data.methods.should_not include(:ext_method)
+          expect(message.data.methods).not_to include(:ext_method)
 
           Configuration.add_available_data_extension('string_type', ExtensionModule)
           message = Message.new('string_type')
-          message.data.methods.should include(:ext_method)
+          expect(message.data.methods).to include(:ext_method)
         end
       end
     end
@@ -138,17 +138,17 @@ class RFlow
 
       @raw_schema = Configuration.available_data_types['RFlow::Message::Data::Raw']['avro']
 
-      encode_avro(@raw_schema, message.data.data_object).should == message.data.to_avro
-      decode_avro(@raw_schema, message.data.to_avro).should == message.data.data_object
+      expect(encode_avro(@raw_schema, message.data.data_object)).to eq(message.data.to_avro)
+      expect(decode_avro(@raw_schema, message.data.to_avro)).to eq(message.data.data_object)
 
       message_data_avro = message.data.to_avro.force_encoding('BINARY')
       processed_message_data_avro = processed_message.data.to_avro.force_encoding('BINARY')
 
-      Digest::MD5.hexdigest(message_avro).should == Digest::MD5.hexdigest(processed_message_avro)
+      expect(Digest::MD5.hexdigest(message_avro)).to eq(Digest::MD5.hexdigest(processed_message_avro))
 
-      message_data_avro.should == processed_message_data_avro
-      Digest::MD5.hexdigest(message_data_avro).should == Digest::MD5.hexdigest(processed_message_data_avro)
-      Digest::MD5.hexdigest(message.data.raw).should == Digest::MD5.hexdigest(processed_message.data.raw)
+      expect(message_data_avro).to eq(processed_message_data_avro)
+      expect(Digest::MD5.hexdigest(message_data_avro)).to eq(Digest::MD5.hexdigest(processed_message_data_avro))
+      expect(Digest::MD5.hexdigest(message.data.raw)).to eq(Digest::MD5.hexdigest(processed_message.data.raw))
     end
   end
 end

data/spec/rflow_spec.rb

@@ -36,7 +36,7 @@ describe RFlow do
         sleep(5)
 
         # Shut down the workers, the reactor, and the thread
-        RFlow.master.shutdown! 'SIGQUIT'
+        RFlow.master.shutdown! 'SIGQUIT' if RFlow.master
         EM.run { EM.stop }
         rflow_thread.join
       end
@@ -64,8 +64,8 @@ describe RFlow do
           c.connect 'generate_ints2#even_odd_out' => 'output_even_odd2#in'
         end
 
-        RFlow.master.should have(1).shard
-        RFlow.master.shards.first.should have(1).worker
+        expect(RFlow.master).to have(1).shard
+        expect(RFlow.master.shards.first).to have(1).worker
 
         output_files = {
           'out'           => [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
@@ -77,8 +77,8 @@ describe RFlow do
         }
 
         output_files.each do |file_name, expected_contents|
-          File.exist?(File.join(@temp_directory_path, file_name)).should be true
-          File.readlines(file_name).map(&:to_i).should == expected_contents
+          expect(File.exist?(File.join(@temp_directory_path, file_name))).to be true
+          expect(File.readlines(file_name).map(&:to_i)).to eq(expected_contents)
         end
       end
 
@@ -114,9 +114,9 @@ describe RFlow do
           c.connect 'generate_ints3#out' => 'output_all#in'
         end
 
-        RFlow.master.should have(4).shards
-        RFlow.master.shards.map(&:count).should == [1, 3, 2, 2]
-        RFlow.master.shards.map(&:workers).map(&:count).should == [1, 3, 2, 2]
+        expect(RFlow.master).to have(4).shards
+        expect(RFlow.master.shards.map(&:count)).to eq([1, 3, 2, 2])
+        expect(RFlow.master.shards.map(&:workers).map(&:count)).to eq([1, 3, 2, 2])
 
         output_files = {
           'out1'    => [0, 3, 6, 9] * 3,
@@ -126,8 +126,8 @@ describe RFlow do
         }
 
         output_files.each do |file_name, expected_contents|
-          File.exist?(File.join(@temp_directory_path, file_name)).should be true
-          File.readlines(file_name).map(&:to_i).sort.should == expected_contents.sort
+          expect(File.exist?(File.join(@temp_directory_path, file_name))).to be true
+          expect(File.readlines(file_name).map(&:to_i).sort).to eq(expected_contents.sort)
         end
       end
     end
@@ -157,13 +157,13 @@ describe RFlow do
         r = execute_rflow("load -d #{db_file_name} -c #{config_file_name}")
 
         # Make sure that the process execution worked
-        r[:status].exitstatus.should == 0
-        r[:stderr].should == ''
-        r[:stdout].should match /Successfully initialized database.*#{db_file_name}/
+        expect(r[:status].exitstatus).to eq(0)
+        expect(r[:stderr]).to eq('')
+        expect(r[:stdout]).to match /Successfully initialized database.*#{db_file_name}/
 
         # Make sure the config actually got loaded
         ActiveRecord::Base.establish_connection adapter: "sqlite3", database: db_file_name
-        RFlow::Configuration::Setting.where(:name => 'mysetting').first.value.should == 'myvalue'
+        expect(RFlow::Configuration::Setting.where(:name => 'mysetting').first.value).to eq('myvalue')
       end
 
       it "should not load a database if the database file already exists" do
@@ -172,9 +172,9 @@ describe RFlow do
         r = execute_rflow("load -d #{db_file_name} -c #{config_file_name}")
 
         # Make sure that the process execution worked
-        r[:status].exitstatus.should == 1
-        r[:stderr].should == ''
-        r[:stdout].should match /Config database.*#{db_file_name}.*exists/
+        expect(r[:status].exitstatus).to eq(1)
+        expect(r[:stderr]).to eq('')
+        expect(r[:stdout]).to match /Config database.*#{db_file_name}.*exists/
       end
     end
 
@@ -215,34 +215,34 @@ describe RFlow do
           EOF
         end
         r = execute_rflow("load -d #{db_file_name} -c #{config_file_name}")
-        r[:status].exitstatus.should == 0
-        r[:stderr].should == ''
-        r[:stdout].should match /Successfully initialized database.*#{db_file_name}/
+        expect(r[:status].exitstatus).to eq(0)
+        expect(r[:stderr]).to eq('')
+        expect(r[:stdout]).to match /Successfully initialized database.*#{db_file_name}/
       end
 
       it "should not start if the components aren't loaded" do
         r = execute_rflow("start -d #{db_file_name} -f")
 
-        r[:status].exitstatus.should == 1
-        r[:stderr].should == ''
-        r[:stdout].should match /error/i
+        expect(r[:status].exitstatus).to eq(1)
+        expect(r[:stderr]).to eq('')
+        expect(r[:stdout]).to match /error/i
       end
 
       it "should daemonize and run in the background" do
         begin
           r = execute_rflow("start -d #{db_file_name} -e #{@extensions_file_name}")
 
-          r[:status].exitstatus.should == 0
-          r[:stderr].should == ''
-          r[:stdout].should_not match /error/i
+          expect(r[:status].exitstatus).to eq(0)
+          expect(r[:stderr]).to eq('')
+          expect(r[:stdout]).not_to match /error/i
 
           sleep 2 # give the daemon a chance to finish
 
           log_contents = File.read("log/#{app_name}.log").chomp
           log_lines = log_contents.split("\n")
 
-          log_lines.each {|line| line.should_not match /^ERROR/ }
-          log_lines.each {|line| line.should_not match /^DEBUG/ }
+          log_lines.each {|line| expect(line).not_to match /^ERROR/ }
+          log_lines.each {|line| expect(line).not_to match /^DEBUG/ }
 
           # Grab all the pids from the log, which seems to be the only
           # reliable way to get them
@@ -252,15 +252,15 @@ describe RFlow do
           master_pid = File.read("run/#{app_name}.pid").chomp.to_i
           worker_pids = log_pids - [initial_pid, master_pid]
 
-          log_pids.should include initial_pid
-          log_pids.should include master_pid
+          expect(log_pids).to include initial_pid
+          expect(log_pids).to include master_pid
 
-          worker_pids.should have(8).pids
-          worker_pids.should_not include 0
+          expect(worker_pids).to have(10).pids # 1+3+2+2 workers, 2 brokers
+          expect(worker_pids).not_to include 0
 
           expect { Process.kill(0, initial_pid) }.to raise_error(Errno::ESRCH)
           ([master_pid] + worker_pids).each do |pid|
-            Process.kill(0, pid).should == 1
+            expect(Process.kill(0, pid)).to eq(1)
           end
 
           output_files = {
@@ -271,15 +271,15 @@ describe RFlow do
           }
 
           output_files.each do |file_name, expected_contents|
-            File.exist?(File.join(@temp_directory_path, file_name)).should be true
-            File.readlines(file_name).map(&:to_i).sort.should == expected_contents.sort
+            expect(File.exist?(File.join(@temp_directory_path, file_name))).to be true
+            expect(File.readlines(file_name).map(&:to_i).sort).to eq(expected_contents.sort)
           end
 
           # Terminate the master
-          Process.kill("TERM", master_pid).should == 1
+          expect(Process.kill("TERM", master_pid)).to eq(1)
 
           # Make sure everything is dead after a second
-          sleep 1
+          sleep 2
           ([master_pid] + worker_pids).each do |pid|
             expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
           end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'rflow')
 require 'fileutils'
 require 'log4r'
 require 'rspec/collection_matchers'
+require 'tmpdir'
 
 I18n.enforce_available_locales = true
 
@@ -11,17 +12,14 @@ RSpec.configure do |config|
     RFlow.logger = Log4r::Logger.new 'test'
     RFlow.logger.add Log4r::StdoutOutputter.new('test_stdout', :formatter => RFlow::Logger::LOG_PATTERN_FORMATTER)
     RFlow.logger.level = 5
-    @base_temp_directory_path = File.join(File.dirname(__FILE__), 'tmp')
   end
 
   config.before(:each) do
-    @entropy = Time.now.to_f.to_s
-    @temp_directory_path = File.expand_path(File.join(@base_temp_directory_path, @entropy))
-    FileUtils.mkdir_p @temp_directory_path
+    @temp_directory_path = Dir.mktmpdir('rflow')
   end
 
   config.after(:each) do
-    FileUtils.rm_rf @base_temp_directory_path
+    FileUtils.rm_rf @temp_directory_path
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rflow
 version: !ruby/object:Gem::Version
-  version: 1.0.0a2
+  version: 1.0.0a3
 platform: ruby
 authors:
 - Michael L. Artz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2014-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools
@@ -84,86 +84,86 @@ dependencies:
   name: em-zeromq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-collection_matchers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '10.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0.8'
 description: A Ruby flow-based programming framework that utilizes ZeroMQ for component
   connections and Avro for serialization
 email:
@@ -183,14 +183,17 @@ files:
 - Guardfile
 - LICENSE
 - NOTES
+- README.VAGRANT
 - README.md
 - Rakefile
+- Vagrantfile
 - bin/rflow
 - example/basic_config.rb
 - example/basic_extensions.rb
 - example/http_config.rb
 - example/http_extensions.rb
 - lib/rflow.rb
+- lib/rflow/broker.rb
 - lib/rflow/child_process.rb
 - lib/rflow/component.rb
 - lib/rflow/component/port.rb
@@ -262,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
 summary: A Ruby flow-based programming framework