rflow 1.0.0a2 → 1.0.0a3

data/lib/rflow/connection.rb

@@ -7,6 +7,8 @@ class RFlow
         case config.type
         when 'RFlow::Configuration::ZMQConnection'
           RFlow::Connections::ZMQConnection.new(config)
+        when 'RFlow::Configuration::BrokeredZMQConnection'
+          RFlow::Connections::BrokeredZMQConnection.new(config)
         else
           raise ArgumentError, "Only ZMQConnections currently supported"
         end
@@ -18,6 +20,7 @@ class RFlow
     protected
     attr_reader :recv_callback
 
+    public
     def initialize(config)
       @config = config
       @uuid = config.uuid
@@ -56,6 +59,9 @@ class RFlow
     def recv_callback
       @recv_callback ||= Proc.new {|message|}
     end
+
+    def input_port_key; config.input_port_key; end
+    def output_port_key; config.output_port_key; end
   end
 
   # Primarily for testing purposes. Captures whatever messages are sent on it.
@@ -77,14 +83,13 @@ class RFlow
   # contain other components within it, shuttling messages in and out without
   # making the internal component visible to the larger RFlow network.
   class ForwardToOutputPort < Connection
-    def initialize(receiver, port_name)
+    def initialize(target_port)
       super(RFlow::Configuration::NullConfiguration.new)
-      @receiver = receiver
-      @port_name = port_name.to_sym
+      @target_port = target_port
     end
 
     def send_message(message)
-      @receiver.send(@port_name).send_message(message)
+      @target_port.send_message(message)
     end
   end
 
@@ -93,15 +98,14 @@ class RFlow
   # contain other components within it, shuttling messages in and out without
   # making the internal component visible to the larger RFlow network.
   class ForwardToInputPort < Connection
-    def initialize(receiver, port_name, port_key)
+    def initialize(target_port)
       super(RFlow::Configuration::NullConfiguration.new)
-      @receiver = receiver
-      @port_name = port_name.to_sym
-      @port_key = port_key
+      @receiver = target_port.component
+      @target_port = target_port
     end
 
     def send_message(message)
-      @receiver.process_message(@receiver.send(@port_name), @port_key, self, message)
+      @receiver.process_message(@target_port, nil, self, message)
     end
   end
 end

data/lib/rflow/connections/zmq_connection.rb

@@ -1,6 +1,11 @@
-require 'em-zeromq'
+begin
+  require 'em-zeromq'
+rescue Exception => e
+  raise LoadError, 'Error loading ZeroMQ; perhaps the wrong system library version is installed?'
+end
 require 'rflow/connection'
 require 'rflow/message'
+require 'rflow/broker'
 
 class RFlow
   module Connections
@@ -9,7 +14,8 @@ class RFlow
         attr_accessor :zmq_context
 
         def create_zmq_context
-          RFlow.logger.debug "Creating a new ZeroMQ context"
+          version = LibZMQ::version
+          RFlow.logger.debug { "Creating a new ZeroMQ context; ZeroMQ version is #{version[:major]}.#{version[:minor]}.#{version[:patch]}" }
           if EM.reactor_running?
             raise RuntimeError, "EventMachine reactor is running when attempting to create a ZeroMQ context"
           end
@@ -22,7 +28,7 @@ class RFlow
         end
       end
 
-      def zmq_context; self.class.zmq_context; end
+      def zmq_context; ZMQConnection.zmq_context; end
 
       private
       attr_accessor :input_socket, :output_socket
@@ -94,5 +100,42 @@ class RFlow
         true
       end
     end
+
+    class BrokeredZMQConnection < ZMQConnection
+    end
+
+    # The broker process responsible for shuttling messages back and forth on a
+    # many-to-many pipeline link. (Solutions without a broker only allow a
+    # 1-to-many or many-to-1 connection.)
+    class ZMQStreamer < Broker
+      private
+      attr_reader :connection, :context, :back, :front
+
+      public
+      def initialize(config)
+        @connection = config.connection
+        super("broker-#{connection.name}", 'Broker')
+      end
+
+      def run_process
+        version = LibZMQ::version
+        RFlow.logger.debug { "Creating a new ZeroMQ context; ZeroMQ version is #{version[:major]}.#{version[:minor]}.#{version[:patch]}" }
+        @context = ZMQ::Context.new
+        RFlow.logger.debug { "Connecting message broker to route from #{connection.options['output_address']} to #{connection.options['input_address']}" }
+        @back = context.socket(ZMQ::PULL)
+        back.bind(connection.options['output_address'])
+        @front = context.socket(ZMQ::PUSH)
+        front.bind(connection.options['input_address'])
+        ZMQ::Proxy.new(back, front)
+        back.close
+        front.close
+      rescue Exception => e
+        RFlow.logger.error "Error running message broker: #{e.class}: #{e.message}, because: #{e.backtrace.inspect}"
+      ensure
+        back.close if back
+        front.close if front
+        context.terminate if context
+      end
+    end
   end
 end

data/lib/rflow/daemon_process.rb

@@ -146,7 +146,7 @@ class RFlow
     end
 
     def signal_subprocesses(signal)
-      subprocesses.each do |p|
+      subprocesses.reject {|p| p.pid.nil? }.each do |p|
         RFlow.logger.info "Signaling #{p.name} with #{signal}"
         Process.kill(signal, p.pid)
       end

data/lib/rflow/master.rb

@@ -1,15 +1,18 @@
 require 'rflow/daemon_process'
 require 'rflow/pid_file'
 require 'rflow/shard'
+require 'rflow/broker'
 
 class RFlow
   class Master < DaemonProcess
     attr_reader :shards
+    attr_reader :brokers
 
     def initialize(config)
       super(config['rflow.application_name'], 'Master')
       @pid_file = PIDFile.new(config['rflow.pid_file_path'])
       @shards = config.shards.map {|config| Shard.new(config) }
+      @brokers = config.connections.flat_map(&:brokers).map {|config| Broker.build(config) }
     end
 
     def run!
@@ -20,11 +23,15 @@ class RFlow
     end
 
     def spawn_subprocesses
+      RFlow.logger.debug "Running #{brokers.count} brokers" if brokers.count > 0
+      brokers.each(&:spawn!)
+      RFlow.logger.debug "#{brokers.count} brokers started: #{brokers.map { |w| "#{w.name} (#{w.pid})" }.join(", ")}" if brokers.count > 0
+
       shards.each(&:run!)
     end
 
     def subprocesses
-      shards.flat_map(&:workers)
+      brokers + shards.flat_map(&:workers)
     end
 
     def run_process

data/lib/rflow/shard.rb

@@ -38,11 +38,17 @@ class RFlow
         end
       end
 
+      # Connect all inputs before all outputs, so connection types that require a 'server'
+      # to be established before a 'client' can connect can get themselves ready.
       def connect_components!
         RFlow.logger.debug "Connecting components"
         @components.each do |component|
-          RFlow.logger.debug "Connecting component '#{component.name}' (#{component.uuid})"
-          component.connect!
+          RFlow.logger.debug "Connecting inputs for component '#{component.name}' (#{component.uuid})"
+          component.connect_inputs!
+        end
+        @components.each do |component|
+          RFlow.logger.debug "Connecting outputs for component '#{component.name}' (#{component.uuid})"
+          component.connect_outputs!
         end
       end
 

data/lib/rflow/version.rb

@@ -1,3 +1,3 @@
 class RFlow
-  VERSION = "1.0.0a2"
+  VERSION = "1.0.0a3"
 end

data/rflow.gemspec

@@ -26,11 +26,11 @@ Gem::Specification.new do |s|
   s.add_dependency "activerecord", "~> 3.2"
 
   s.add_dependency "avro", "~> 1.7.5"
-  s.add_dependency "em-zeromq", "~> 0.4.2"
+  s.add_dependency "em-zeromq", "0.5.0"
 
-  s.add_development_dependency "bundler", "~> 1.5"
-  s.add_development_dependency "rspec", "~> 2.99"
-  s.add_development_dependency "rspec-collection_matchers", "~> 0.0.4"
-  s.add_development_dependency "rake", ">= 0.8.7"
-  s.add_development_dependency "yard", "~> 0.8.7"
+  s.add_development_dependency "bundler", "~> 1.6"
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "rspec-collection_matchers", "~> 1.0"
+  s.add_development_dependency "rake", ">= 10.3"
+  s.add_development_dependency "yard", "~> 0.8"
 end

data/spec/fixtures/extensions_ints.rb

@@ -13,21 +13,20 @@ end
 RFlow::Configuration.add_available_data_extension('RFlow::Message::Data::Integer', SimpleDataExtension)
 
 class RFlow::Components::FileOutput < RFlow::Component
-  attr_accessor :output_file_path, :output_file
+  attr_accessor :output_file_path
   input_port :in
 
   def configure!(config)
     self.output_file_path = config['output_file_path']
-    self.output_file = File.new output_file_path, 'w+'
   end
 
   def process_message(input_port, input_port_key, connection, message)
-    output_file.puts message.data.data_object.inspect
-    output_file.flush
-  end
-
-  def cleanup
-    output_file.close
+    File.open(output_file_path, 'a') do |f|
+      f.flock(File::LOCK_EX)
+      f.puts message.data.data_object.inspect
+      f.flush
+      f.flock(File::LOCK_UN)
+    end
   end
 end
 

data/spec/rflow/component/port_spec.rb

@@ -4,17 +4,13 @@ class RFlow
   class Component
     describe Port do
       it "should not be connected" do
-        described_class.new.should_not be_connected
+        expect(described_class.new(nil)).not_to be_connected
       end
     end
 
     describe HashPort do
       it "should not be connected" do
-        config = double('Port Config')
-        config.stub(:name).and_return('port')
-        config.stub(:uuid).and_return('1')
-
-        described_class.new(config).should_not be_connected
+        expect(described_class.new(nil)).not_to be_connected
       end
     end
 
@@ -22,17 +18,16 @@ class RFlow
       context "#connect!" do
         it "should be connected" do
           connection = double('connection')
-          connection.should_receive(:connect_input!)
-
-          config = double('Port Config')
-          config.stub(:name).and_return('port')
-          config.stub(:uuid).and_return('1')
+          allow(connection).to receive(:name)
+          allow(connection).to receive(:uuid)
+          allow(connection).to receive(:input_port_key)
+          expect(connection).to receive(:connect_input!)
 
-          described_class.new(config).tap do |port|
+          described_class.new(nil).tap do |port|
             port.add_connection(nil, connection)
-            port.should_not be_connected
+            expect(port).not_to be_connected
             port.connect!
-            port.should be_connected
+            expect(port).to be_connected
           end
         end
       end
@@ -42,17 +37,16 @@ class RFlow
       context "#connect!" do
         it "should be connected" do
           connection = double('connection')
-          connection.should_receive(:connect_output!)
-
-          port_config = double('Port Config')
-          port_config.stub(:name).and_return('port')
-          port_config.stub(:uuid).and_return('1')
+          allow(connection).to receive(:name)
+          allow(connection).to receive(:uuid)
+          allow(connection).to receive(:input_port_key)
+          expect(connection).to receive(:connect_output!)
 
-          described_class.new(port_config).tap do |port|
+          described_class.new(nil).tap do |port|
             port.add_connection(nil, connection)
-            port.should_not be_connected
+            expect(port).not_to be_connected
             port.connect!
-            port.should be_connected
+            expect(port).to be_connected
           end
         end
       end

data/spec/rflow/components/clock_spec.rb

@@ -7,15 +7,10 @@ class RFlow
         ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
         Configuration.migrate_database
       end
-      let(:config) do
-        RFlow::Configuration::Component.new.tap do |c|
-          c.output_ports << RFlow::Configuration::OutputPort.new(name: 'tick_port')
-        end
-      end
       let(:message_connection) { RFlow::MessageCollectingConnection.new }
 
       def clock(args = {})
-        Clock.new(config).tap do |c|
+        Clock.new.tap do |c|
           c.configure! args
           c.tick_port.connect!
           c.tick_port.add_connection nil, message_connection
@@ -26,44 +21,44 @@ class RFlow
 
       it 'defaults configuration nicely' do
         clock.tap do |c|
-          c.clock_name.should == 'Clock'
-          c.tick_interval.should == 1
+          expect(c.clock_name).to eq('Clock')
+          expect(c.tick_interval).to eq(1)
         end
       end
 
       it 'supports name overrides' do
         clock('name' => 'testname').tap do |c|
-          c.clock_name.should == 'testname'
+          expect(c.clock_name).to eq('testname')
         end
       end
 
       it 'supports interval overrides for floats' do
         clock('tick_interval' => 1.5).tap do |c|
-          c.tick_interval.should == 1.5
+          expect(c.tick_interval).to eq(1.5)
         end
       end
 
       it 'supports interval overrides for strings' do
         clock('tick_interval' => '1.5').tap do |c|
-          c.tick_interval.should == 1.5
+          expect(c.tick_interval).to eq(1.5)
         end
       end
 
       it 'should register a timer' do
-        EventMachine::PeriodicTimer.should_receive(:new).with(1)
+        expect(EventMachine::PeriodicTimer).to receive(:new).with(1)
         clock.run!
       end
 
       it 'should generate a tick message when asked' do
         clock.tap do |c|
           now = Integer(Time.now.to_f * 1000)
-          messages.should be_empty
+          expect(messages).to be_empty
           c.tick
-          messages.should have(1).message
+          expect(messages).to have(1).message
           messages.first.tap do |m|
-            m.data_type_name.should == 'RFlow::Message::Clock::Tick'
-            m.data.name.should == 'Clock'
-            m.data.timestamp.should >= now
+            expect(m.data_type_name).to eq('RFlow::Message::Clock::Tick')
+            expect(m.data.name).to eq('Clock')
+            expect(m.data.timestamp).to be >= now
           end
         end
       end

data/spec/rflow/configuration/ruby_dsl_spec.rb

@@ -12,10 +12,10 @@ class RFlow
       it "should correctly process an empty DSL" do
         described_class.configure {}
 
-        Shard.should have(0).shards
-        Component.should have(0).components
-        Port.should have(0).ports
-        Connection.should have(0).connections
+        expect(Shard).to have(0).shards
+        expect(Component).to have(0).components
+        expect(Port).to have(0).ports
+        expect(Connection).to have(0).connections
       end
 
       it "should correctly process a component declaration" do
@@ -23,15 +23,15 @@ class RFlow
           c.component 'boom', 'town', 'opt1' => 'OPT1', 'opt2' => 'OPT2'
         end
 
-        Shard.should have(1).shard
-        Component.should have(1).component
-        Port.should have(0).ports
-        Connection.should have(0).connections
+        expect(Shard).to have(1).shard
+        expect(Component).to have(1).component
+        expect(Port).to have(0).ports
+        expect(Connection).to have(0).connections
 
         Component.first.tap do |c|
-          c.name.should == 'boom'
-          c.specification.should == 'town'
-          c.options.should == {'opt1' => 'OPT1', 'opt2' => 'OPT2'}
+          expect(c.name).to eq('boom')
+          expect(c.specification).to eq('town')
+          expect(c.options).to eq('opt1' => 'OPT1', 'opt2' => 'OPT2')
         end
       end
 
@@ -45,38 +45,38 @@ class RFlow
           c.connect 'first#out[outkey]' => 'second#in[inkey]'
         end
 
-        Shard.should have(1).shard
-        Component.should have(2).components
-        Port.should have(2).ports
-        Connection.should have(4).connections
+        expect(Shard).to have(1).shard
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(4).connections
 
         first_component = Component.where(name: 'first').first.tap do |component|
-          component.specification.should == 'First'
-          component.should have(0).input_ports
-          component.should have(1).output_port
-          component.output_ports.first.name.should == 'out'
+          expect(component.specification).to eq('First')
+          expect(component).to have(0).input_ports
+          expect(component).to have(1).output_port
+          expect(component.output_ports.first.name).to eq('out')
 
-          component.output_ports.first.should have(4).connections
+          expect(component.output_ports.first).to have(4).connections
           component.output_ports.first.connections.tap do |connections|
-            connections[0].input_port_key.should be_nil
-            connections[0].output_port_key.should be_nil
-            connections[1].input_port_key.should == 'inkey'
-            connections[1].output_port_key.should be_nil
-            connections[2].input_port_key.should be_nil
-            connections[2].output_port_key.should == 'outkey'
-            connections[3].input_port_key.should == 'inkey'
-            connections[3].output_port_key.should == 'outkey'
+            expect(connections[0].input_port_key).to be_nil
+            expect(connections[0].output_port_key).to be_nil
+            expect(connections[1].input_port_key).to eq('inkey')
+            expect(connections[1].output_port_key).to be_nil
+            expect(connections[2].input_port_key).to be_nil
+            expect(connections[2].output_port_key).to eq('outkey')
+            expect(connections[3].input_port_key).to eq('inkey')
+            expect(connections[3].output_port_key).to eq('outkey')
           end
         end
 
         Component.where(name: 'second').first.tap do |component|
-          component.specification.should == 'Second'
-          component.should have(1).input_port
-          component.input_ports.first.name.should == 'in'
-          component.should have(0).output_ports
+          expect(component.specification).to eq('Second')
+          expect(component).to have(1).input_port
+          expect(component.input_ports.first.name).to eq('in')
+          expect(component).to have(0).output_ports
 
-          component.input_ports.first.should have(4).connections
-          component.input_ports.first.connections.should == first_component.output_ports.first.connections
+          expect(component.input_ports.first).to have(4).connections
+          expect(component.input_ports.first.connections).to eq(first_component.output_ports.first.connections)
         end
       end
 
@@ -93,39 +93,227 @@ class RFlow
             s.component 'fourth', 'Fourth'
           end
 
+          c.process "s3", :count => 10 do |s|
+            s.component 'fifth', 'Fifth'
+          end
+
           c.shard "s-ignored", :type => :process, :count => 10 do
             # ignored because there are no components
           end
 
-          c.component 'fifth', 'Fifth'
+          c.thread "s4", :count => 10 do |s|
+            s.component 'sixth', 'Sixth'
+          end
+
+          c.shard "s5", :type => :thread, :count => 10 do |s|
+            s.component 'seventh', 'Seventh'
+          end
+
+          c.component 'eighth', 'Eighth'
 
           c.connect 'first#out' => 'second#in'
           c.connect 'second#out[outkey]' => 'third#in[inkey]'
           c.connect 'second#out' => 'third#in2'
           c.connect 'third#out' => 'fourth#in'
           c.connect 'third#out' => 'fifth#in'
+          c.connect 'third#out' => 'sixth#in'
         end
 
-        Shard.should have(3).shards
-        Component.should have(5).components
-        Port.should have(8).ports
-        Connection.should have(5).connections
+        expect(Shard).to have(6).shards
+        expect(Component).to have(8).components
+        expect(Port).to have(9).ports
+        expect(Connection).to have(6).connections
 
         Shard.all.tap do |shards|
-          shards.map(&:name).should == ['DEFAULT', 's1', 's2']
-          shards.first.components.all.map(&:name).should == ['first', 'fifth']
-          shards.second.components.all.map(&:name).should == ['second']
-          shards.third.components.all.map(&:name).should == ['third', 'fourth']
+          expect(shards.map(&:name)).to eq(['DEFAULT', 's1', 's2', 's3', 's4', 's5'])
+          expect(shards.map(&:type)).to eq((['RFlow::Configuration::ProcessShard'] * 4) + (['RFlow::Configuration::ThreadShard'] * 2))
+          expect(shards.first.components.all.map(&:name)).to eq(['first', 'eighth'])
+          expect(shards.second.components.all.map(&:name)).to eq(['second'])
+          expect(shards.third.components.all.map(&:name)).to eq(['third', 'fourth'])
+          expect(shards.fourth.components.all.map(&:name)).to eq(['fifth'])
         end
 
-        Port.all.map(&:name).should == ['out', 'in', 'out', 'in', 'in2', 'out', 'in', 'in']
+        expect(Port.all.map(&:name)).to eq(['out', 'in', 'out', 'in', 'in2', 'out', 'in', 'in', 'in'])
 
-        Connection.all.map(&:name).should ==
+        expect(Connection.all.map(&:name)).to eq(
           ['first#out=>second#in',
            'second#out[outkey]=>third#in[inkey]',
            'second#out=>third#in2',
            'third#out=>fourth#in',
-           'third#out=>fifth#in']
+           'third#out=>fifth#in',
+           'third#out=>sixth#in'])
+      end
+
+      it "should generate PUSH-PULL inproc ZeroMQ connections for in-shard connections" do
+        described_class.configure do |c|
+
+          c.shard "s1", :process => 1 do |s|
+            s.component 'first', 'First', :opt1 => 'opt1'
+            s.component 'second', 'Second', :opt1 => 'opt1', "opt2" => "opt2"
+          end
+
+          c.connect 'first#out' => 'second#in'
+        end
+
+        expect(Shard).to have(1).shards
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(1).connections
+
+        Connection.first.tap do |conn|
+          expect(conn.type).to eq('RFlow::Configuration::ZMQConnection')
+          expect(conn.name).to eq('first#out=>second#in')
+          expect(conn.output_port_key).to be_nil
+          expect(conn.input_port_key).to be_nil
+          conn.options.tap do |opts|
+            expect(opts['output_socket_type']).to eq('PUSH')
+            expect(opts['output_address']).to eq("inproc://rflow.#{conn.uuid}")
+            expect(opts['output_responsibility']).to eq('connect')
+            expect(opts['input_socket_type']).to eq('PULL')
+            expect(opts['input_address']).to eq("inproc://rflow.#{conn.uuid}")
+            expect(opts['input_responsibility']).to eq('bind')
+          end
+        end
+      end
+
+      it "should generate PUSH-PULL ipc ZeroMQ connections for one-to-one inter-shard connections" do
+        described_class.configure do |c|
+
+          c.shard "s1", :process => 1 do |s|
+            s.component 'first', 'First', :opt1 => 'opt1'
+          end
+
+          c.shard "s2", :process => 1 do |s|
+            s.component 'second', 'Second', :opt1 => 'opt1', "opt2" => "opt2"
+          end
+
+          c.connect 'first#out' => 'second#in'
+        end
+
+        expect(Shard).to have(2).shards
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(1).connections
+
+        Connection.first.tap do |conn|
+          expect(conn.type).to eq('RFlow::Configuration::ZMQConnection')
+          expect(conn.name).to eq('first#out=>second#in')
+          expect(conn.output_port_key).to be_nil
+          expect(conn.input_port_key).to be_nil
+          conn.options.tap do |opts|
+            expect(opts['output_socket_type']).to eq('PUSH')
+            expect(opts['output_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['output_responsibility']).to eq('connect')
+            expect(opts['input_socket_type']).to eq('PULL')
+            expect(opts['input_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['input_responsibility']).to eq('bind')
+          end
+        end
+      end
+
+      it "should generate PUSH-PULL ipc ZeroMQ connections for one-to-many inter-shard connections" do
+        described_class.configure do |c|
+
+          c.shard "s1", :process => 1 do |s|
+            s.component 'first', 'First', :opt1 => 'opt1'
+          end
+
+          c.shard "s2", :process => 3 do |s|
+            s.component 'second', 'Second', :opt1 => 'opt1', "opt2" => "opt2"
+          end
+
+          c.connect 'first#out' => 'second#in'
+        end
+
+        expect(Shard).to have(2).shards
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(1).connections
+
+        Connection.first.tap do |conn|
+          expect(conn.type).to eq('RFlow::Configuration::ZMQConnection')
+          expect(conn.name).to eq('first#out=>second#in')
+          expect(conn.output_port_key).to be_nil
+          expect(conn.input_port_key).to be_nil
+          conn.options.tap do |opts|
+            expect(opts['output_socket_type']).to eq('PUSH')
+            expect(opts['output_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['output_responsibility']).to eq('bind')
+            expect(opts['input_socket_type']).to eq('PULL')
+            expect(opts['input_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['input_responsibility']).to eq('connect')
+          end
+        end
+      end
+
+      it "should generate PUSH-PULL ipc ZeroMQ connections for many-to-one inter-shard connections" do
+        described_class.configure do |c|
+
+          c.shard "s1", :process => 3 do |s|
+            s.component 'first', 'First', :opt1 => 'opt1'
+          end
+
+          c.shard "s2", :process => 1 do |s|
+            s.component 'second', 'Second', :opt1 => 'opt1', "opt2" => "opt2"
+          end
+
+          c.connect 'first#out' => 'second#in'
+        end
+
+        expect(Shard).to have(2).shards
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(1).connections
+
+        Connection.first.tap do |conn|
+          expect(conn.type).to eq('RFlow::Configuration::ZMQConnection')
+          expect(conn.name).to eq('first#out=>second#in')
+          expect(conn.output_port_key).to be_nil
+          expect(conn.input_port_key).to be_nil
+          conn.options.tap do |opts|
+            expect(opts['output_socket_type']).to eq('PUSH')
+            expect(opts['output_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['output_responsibility']).to eq('connect')
+            expect(opts['input_socket_type']).to eq('PULL')
+            expect(opts['input_address']).to eq("ipc://rflow.#{conn.uuid}")
+            expect(opts['input_responsibility']).to eq('bind')
+          end
+        end
+      end
+
+      it "should generate PUSH-PULL brokered ZeroMQ connections for many-to-many inter-shard connections" do
+        described_class.configure do |c|
+
+          c.shard "s1", :process => 3 do |s|
+            s.component 'first', 'First', :opt1 => 'opt1'
+          end
+
+          c.shard "s2", :process => 3 do |s|
+            s.component 'second', 'Second', :opt1 => 'opt1', "opt2" => "opt2"
+          end
+
+          c.connect 'first#out' => 'second#in'
+        end
+
+        expect(Shard).to have(2).shards
+        expect(Component).to have(2).components
+        expect(Port).to have(2).ports
+        expect(Connection).to have(1).connections
+
+        Connection.first.tap do |conn|
+          expect(conn.type).to eq('RFlow::Configuration::BrokeredZMQConnection')
+          expect(conn.name).to eq('first#out=>second#in')
+          expect(conn.output_port_key).to be_nil
+          expect(conn.input_port_key).to be_nil
+          conn.options.tap do |opts|
+            expect(opts['output_socket_type']).to eq('PUSH')
+            expect(opts['output_address']).to eq("ipc://rflow.#{conn.uuid}.in")
+            expect(opts['output_responsibility']).to eq('connect')
+            expect(opts['input_socket_type']).to eq('PULL')
+            expect(opts['input_address']).to eq("ipc://rflow.#{conn.uuid}.out")
+            expect(opts['input_responsibility']).to eq('connect')
+          end
+        end
       end
 
       it "should not allow two components with the same name" do