zmachine 0.2.1 → 0.3.0

data/spec/channel_spec.rb

@@ -0,0 +1,178 @@
+require 'zmachine/tcp_channel'
+require 'zmachine/zmq_channel'
+
+include ZMachine
+
+shared_examples_for "a Channel" do
+
+  context '#bind' do
+
+    it 'binds a server socket' do
+      expect(@server).to be_bound
+    end
+
+    it 'accepts client connections' do
+      channel = @server.accept
+      expect(channel).to be_a(klass)
+      expect(channel).to be_connected
+    end
+
+  end
+
+  context '#connect' do
+
+    it 'connects to a pending server socket' do
+      expect(@client).to be_connection_pending
+    end
+
+    it 'connects to an accepted server socket' do
+      @server.accept
+      @client.finish_connecting
+      expect(@client).to be_connected
+    end
+
+  end
+
+  context '#send/recv' do
+
+    before(:each) do
+      @channel = @server.accept
+      @channel.raw = false
+      @client.finish_connecting
+    end
+
+    it 'writes outbound buffers to the socket' do
+      @client.send_data(data)
+      expect(@client.write_outbound_data).to eq(true)
+    end
+
+    it 'receives data sent from the client' do
+      @client.send_data(data)
+      @client.write_outbound_data
+      received = @channel.read_inbound_data
+      expect(received.to_s).to eq(data.to_s)
+    end
+
+    it 'receives data sent from the server' do
+      @client.send_data(data)
+      @client.write_outbound_data
+      received = @channel.read_inbound_data
+      @channel.send_data(data)
+      @channel.write_outbound_data
+      received = @client.read_inbound_data
+      expect(received.to_s).to eq(data.to_s)
+    end
+
+  end
+
+  context '#close' do
+
+    it 'closes the client connection' do
+      @client.close
+      expect(@client).to be_closed
+    end
+
+    it 'closes the server connection' do
+      @server.close
+      expect(@server).to be_closed
+    end
+
+    it 'closes the accepted connection' do
+      channel = @server.accept
+      channel.close
+      expect(channel).to be_closed
+    end
+
+    it 'closes the connection after writing' do
+      channel = @server.accept
+      @client.finish_connecting
+      @client.send_data(data)
+      @client.close(true)
+      expect(@client).to be_connected
+      @client.write_outbound_data
+      expect(@client).not_to be_connected
+    end
+
+  end
+
+end
+
+describe TCPChannel do
+
+  it_behaves_like "a Channel"
+
+  let(:klass) { TCPChannel }
+  let(:address) { "0.0.0.0" }
+  let(:port_or_type) { [51635, 51635] }
+
+  before(:each) do
+    @server = klass.new
+    @server.bind(address, port_or_type[0])
+    @client = klass.new
+    @client.connect(address, port_or_type[1])
+  end
+
+  after(:each) do
+    @client.close
+    @server.close
+    ZMachine.context.destroy
+  end
+
+  let(:data) { "foo".to_java_bytes }
+
+  it 'has the correct peer information' do
+    expect(@client.peer).to eq([port_or_type[0], address])
+    channel = @server.accept
+    @client.finish_connecting
+    socket = @client.socket.socket
+    expect(channel.peer).to eq([socket.local_port, socket.local_address.host_address])
+  end
+
+  context '#send/recv' do
+
+    it 'reads data after server has closed connection' do
+      channel = @server.accept
+      @client.finish_connecting
+      channel.send_data(data)
+      channel.close(true)
+      expect(channel).to be_connected
+      channel.write_outbound_data
+      expect(channel).not_to be_connected
+      expect(@client).to be_connected
+      @client.read_inbound_data
+      expect{@client.read_inbound_data}.to raise_error(IOException)
+    end
+
+  end
+
+end
+
+describe ZMQChannel do
+
+  it_behaves_like "a Channel"
+
+  let(:klass) { ZMQChannel }
+  let(:address) { "tcp://0.0.0.0:51634" }
+  let(:port_or_type) { [ZMQ::REP, ZMQ::REQ] }
+
+  before(:each) do
+    @server = klass.new
+    @server.bind(address, port_or_type[0])
+    @client = klass.new
+    @client.connect(address, port_or_type[1])
+    @client.raw = false
+  end
+
+  after(:each) do
+    @client.close
+    @server.close
+    ZMachine.context.destroy
+  end
+
+  let(:data) { "foo".to_java_bytes }
+
+  it 'has no concept of a peer' do
+    expect{@client.peer}.to raise_error(RuntimeError)
+  end
+
+end

data/spec/connection_spec.rb

@@ -2,17 +2,19 @@ require 'zmachine/connection'
 
 include ZMachine
 
-describe Connection do
+shared_examples_for "a Connection" do
 
   before(:each) do
-    @server = Connection.new.bind("0.0.0.0", 0)
-    @port = @server.channel.socket.socket.local_port
-    @client = Connection.new.connect("0.0.0.0", @port)
+    @server = Connection.new.bind(address, port_or_type[0]) { |c| @accepted = c }
+    @server.channel.raw = false
+    @client = Connection.new.connect(address, port_or_type[1]) { |c| @connection = c }
+    @client.channel.raw = false
   end
 
   after(:each) do
     @client.close
     @server.close
+    ZMachine.context.destroy
   end
 
   let(:data) { "foo" }
@@ -20,16 +22,17 @@ describe Connection do
   context 'triggers' do
 
     it 'triggers acceptable' do
-      @server.channel.should_receive(:accept).once.and_call_original
-      @server.should_receive(:connection_accepted).once
+      @server.channel.should_receive(:accept).and_call_original
       connection = @server.acceptable!
       expect(connection).to be_connected
+      expect(@accepted).to eq(connection)
+      expect(@connection).to be_a(Connection)
     end
 
     it 'triggers connectable' do
       @server.acceptable!
-      @client.channel.should_receive(:finish_connecting).once.and_call_original
-      @client.should_receive(:connection_completed).once
+      @client.channel.should_receive(:finish_connecting).and_call_original
+      @client.should_receive(:connection_completed)
       @client.connectable!
       expect(@client).to be_connected
     end
@@ -37,7 +40,7 @@ describe Connection do
     it 'triggers writable' do
       @server.acceptable!
       @client.connectable!
-      @client.send_data(data.to_java_bytes)
+      @client.send_data(data)
       @client.channel.should_receive(:write_outbound_data).and_call_original
       @client.writable!
     end
@@ -45,12 +48,34 @@ describe Connection do
     it 'triggers readable' do
       connection = @server.acceptable!
       @client.connectable!
-      @client.send_data(data.to_java_bytes)
+      @client.send_data(data)
       @client.writable!
       connection.channel.should_receive(:read_inbound_data).and_call_original
-      connection.should_receive(:receive_data).once
+      connection.should_receive(:receive_data).with(data)
       connection.readable!
     end
 
   end
+
+end
+
+describe Connection do
+
+  context 'TCP' do
+
+    it_behaves_like "a Connection"
+
+    let(:address) { "0.0.0.0" }
+    let(:port_or_type) { [51635, 51635] }
+
+  end
+
+  context 'ZMQ' do
+
+    it_behaves_like "a Connection"
+
+    let(:address) { "tcp://0.0.0.0:51634" }
+    let(:port_or_type) { [ZMQ::REP, ZMQ::REQ] }
+
+  end
 end

data/spec/hashed_wheel_spec.rb

@@ -1,7 +1,7 @@
 require 'zmachine/hashed_wheel'
 
 describe ZMachine::HashedWheel do
-  let(:wheel) { ZMachine::HashedWheel.new(16, 100) }
+  let(:wheel) { ZMachine::HashedWheel.new(16, 0.1) }
 
   it 'returns a timeout on add' do
     expect(wheel.add(0)).to be_instance_of(ZMachine::HashedWheelTimeout)
@@ -9,11 +9,11 @@ describe ZMachine::HashedWheel do
 
   it 'adds timeouts to the correct slot' do
     wheel.add 0
-    wheel.add 90
-    wheel.add 110
-    wheel.add 1000
-    wheel.add 1600
-    wheel.add 3200
+    wheel.add 0.090
+    wheel.add 0.110
+    wheel.add 1.000
+    wheel.add 1.600
+    wheel.add 3.200
     expect(wheel.slots[0].length).to eq(4)
     expect(wheel.slots[1].length).to eq(1)
     expect(wheel.slots[10].length).to eq(1)
@@ -21,19 +21,19 @@ describe ZMachine::HashedWheel do
 
   it 'times out same slot timeouts correctly' do
     now = wheel.reset
-    wheel.add 10
-    wheel.add 50
+    wheel.add 0.01
+    wheel.add 0.05
     timedout = wheel.advance(now + 30 * 1_000_000)
     expect(timedout.length).to eq(1)
   end
 
   it 'calculates the timeout set correctly' do
     now = wheel.reset
-    wheel.add 10
-    wheel.add 40
-    wheel.add 1900
-    wheel.add 3300
-    wheel.add 4000
+    wheel.add 0.010
+    wheel.add 0.040
+    wheel.add 1.900
+    wheel.add 3.300
+    wheel.add 4.000
     timedout = wheel.advance(now + 3900 * 1_000_000)
     expect(timedout).to be
     expect(timedout.length).to eq(4)
@@ -41,8 +41,8 @@ describe ZMachine::HashedWheel do
 
   it 'cancels timers correctly' do
     now = wheel.reset
-    t1 = wheel.add 90
-    t2 = wheel.add 110
+    t1 = wheel.add 0.090
+    t2 = wheel.add 0.110
     t1.cancel
     timedout = wheel.advance(now + 200 * 1_000_000)
     expect(timedout).to eq([t2])

data/spec/support/echo_mock.rb

@@ -0,0 +1,32 @@
+require "socket"
+
+module EchoMock
+  def self.start(port = 6380)
+    server = TCPServer.new("127.0.0.1", port)
+    loop do
+      session = server.accept
+      while line = session.gets
+        session.write(line)
+        session.write("\r\n")
+      end
+    end
+  end
+
+  module Helper
+    def echo_mock
+      begin
+        pid = fork do
+          trap("TERM") { exit }
+          EchoMock.start
+        end
+        sleep 1 # Give time for the socket to start listening.
+        yield
+      ensure
+        if pid
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        end
+      end
+    end
+  end
+end

data/zmachine.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "zmachine"
-  spec.version       = "0.2.1"
+  spec.version       = "0.3.0"
   spec.authors       = ["LiquidM, Inc."]
   spec.email         = ["opensource@liquidm.com"]
   spec.description   = %q{pure JRuby multi-threaded mostly EventMachine compatible event loop}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zmachine
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - LiquidM, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-11-25 00:00:00.000000000 Z
+date: 2013-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid-ext
@@ -42,8 +42,8 @@ files:
 - benchmarks/benchmark.sh
 - benchmarks/tcp_channel.rb
 - benchmarks/zmq_channel.rb
-- echo_client.rb
-- echo_server.rb
+- examples/echo_client.rb
+- examples/echo_server.rb
 - lib/zmachine.rb
 - lib/zmachine/acceptor.rb
 - lib/zmachine/channel.rb
@@ -51,17 +51,17 @@ files:
 - lib/zmachine/connection_manager.rb
 - lib/zmachine/deferrable.rb
 - lib/zmachine/hashed_wheel.rb
-- lib/zmachine/jeromq-0.3.0-SNAPSHOT.jar
+- lib/zmachine/jeromq-0.3.2-SNAPSHOT.jar
 - lib/zmachine/reactor.rb
 - lib/zmachine/tcp_channel.rb
 - lib/zmachine/timers.rb
 - lib/zmachine/zmq_channel.rb
+- spec/channel_spec.rb
 - spec/connection_manager_spec.rb
 - spec/connection_spec.rb
 - spec/hashed_wheel_spec.rb
 - spec/spec_helper.rb
-- spec/tcp_channel_spec.rb
-- spec/zmq_channel_spec.rb
+- spec/support/echo_mock.rb
 - zmachine.gemspec
 homepage: https://github.com/liquidm/zmachine
 licenses:
@@ -88,10 +88,10 @@ signing_key:
 specification_version: 4
 summary: pure JRuby multi-threaded mostly EventMachine compatible event loop
 test_files:
+- spec/channel_spec.rb
 - spec/connection_manager_spec.rb
 - spec/connection_spec.rb
 - spec/hashed_wheel_spec.rb
 - spec/spec_helper.rb
-- spec/tcp_channel_spec.rb
-- spec/zmq_channel_spec.rb
+- spec/support/echo_mock.rb
 has_rdoc:

data/spec/tcp_channel_spec.rb

@@ -1,109 +0,0 @@
-require 'zmachine/tcp_channel'
-
-include ZMachine
-
-describe ZMachine::TCPChannel do
-
-  before(:each) do
-    @server = TCPChannel.new
-    @server.bind("0.0.0.0", 0)
-    @port = @server.socket.socket.local_port
-    @client = TCPChannel.new
-    @client.connect("0.0.0.0", @port)
-  end
-
-  after(:each) do
-    @client.close
-    @server.close
-  end
-
-  let(:data) { "foo" }
-
-  context '#bind' do
-
-    it 'binds a server socket' do
-      expect(@server).to be_bound
-    end
-
-    it 'accepts client connections' do
-      channel = @server.accept
-      expect(channel).to be_a(TCPChannel)
-      expect(channel).to be_connected
-    end
-
-  end
-
-  context '#connect' do
-
-    it 'connects to a pending server socket' do
-      expect(@client).to be_connection_pending
-    end
-
-    it 'connects to an accepted server socket' do
-      @server.accept
-      @client.finish_connecting
-      expect(@client).to be_connected
-    end
-
-  end
-
-  context '#send/recv' do
-
-    before(:each) do
-      @channel = @server.accept
-      @client.finish_connecting
-      @client.send_data(data.to_java_bytes)
-    end
-
-    it 'writes outbound buffers to the socket' do
-      expect(@client.write_outbound_data).to eq(true)
-    end
-
-    it 'receives data sent from the client' do
-      @client.write_outbound_data
-      received = @channel.read_inbound_data
-      expect(received).to eq(data)
-    end
-
-    it 'receives data sent from the server' do
-      @client.write_outbound_data
-      received = @channel.read_inbound_data
-      @channel.send_data(data.to_java_bytes)
-      @channel.write_outbound_data
-      received = @client.read_inbound_data
-      expect(received).to eq(data)
-    end
-
-  end
-
-  context '#close' do
-
-    it 'closes the client connection' do
-      @client.close
-      expect(@client).to be_closed
-    end
-
-    it 'closes the server connection' do
-      @server.close
-      expect(@server).to be_closed
-    end
-
-    it 'closes the accepted connection' do
-      channel = @server.accept
-      channel.close
-      expect(channel).to be_closed
-    end
-
-    it 'closes the connection after writing' do
-      channel = @server.accept
-      @client.finish_connecting
-      @client.send_data(data.to_java_bytes)
-      @client.close_after_writing
-      expect(@client).to be_connected
-      @client.write_outbound_data
-      expect(@client).not_to be_connected
-    end
-
-  end
-
-end