cool.io 1.4.1-x64-mingw32

data/spec/tcp_socket_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Coolio::TCPSocket do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = TCPServer.new("127.0.0.1", 0)
+    @host = @echo.addr[3]
+    @port = @echo.addr[1]
+    @running = true
+    @echo_thread = Thread.new do
+      socks = [@echo]
+      begin
+        serv socks
+      ensure
+        socks.each do |s|
+          s.close
+        end
+      end
+      Thread.pass
+    end
+  end
+  
+  def serv(socks)
+    while @running
+      selected = select(socks, [], [], 0.1)
+      next if selected.nil?
+      selected[0].each do |s|
+        if s == @echo
+          socks.push s.accept
+          next
+        end
+        begin
+          unless s.eof?
+            s.write(s.read_nonblock 1)
+          end
+        rescue SystemCallError, EOFError, IOError, SocketError
+        end
+      end
+    end
+  end
+  
+  def shutdown
+    if @running
+      @running = false
+      @echo_thread.join
+    end
+  end
+  
+  after :each do
+    shutdown
+  end
+
+  context "#close" do
+    it "detaches all watchers on #close before loop#run" do
+      client = Coolio::TCPSocket.connect(@host, @port)
+      loop.attach client
+      client.close
+      expect(loop.watchers.size).to eq 0
+    end
+  end
+
+  context "#on_connect" do
+    class OnConnect < Cool.io::TCPSocket
+      attr :connected
+      def on_connect
+        @connected = true
+      end
+    end
+    
+    it "connected client called on_connect" do
+      begin
+        c = OnConnect.connect(@host, @port)
+        loop.attach c
+        loop.run_once
+        expect(c.connected).to eq true
+      ensure
+        c.close
+      end
+    end
+  end
+
+  context "#on_connect_failed" do
+    class OnConnectFailed < Cool.io::TCPSocket
+      attr :connect_failed
+      def on_connect_failed
+        @connect_failed = true
+      end
+    end
+    
+    it "try to connect dead host" do
+      serv = TCPServer.new(0)
+      dead_host = serv.addr[3]
+      dead_port = serv.addr[1]
+      serv.close
+      
+      c = OnConnectFailed.connect(dead_host, dead_port)
+      loop.attach c
+      loop.run_once # on_connect_failed
+      expect(c.connect_failed).to eq true
+    end
+  end
+
+  context "#on_close" do
+    class Closed < StandardError; end
+    class OnClose < Cool.io::TCPSocket
+      def on_close
+        raise Closed
+      end
+    end
+    
+    let :client do
+      OnClose.connect(@host, @port)
+    end
+    
+    before :each do
+      loop.attach client
+      loop.run_once # on_connect
+      client.write "0"
+    end
+    
+    it "disconnect from client" do
+      expect { client.close }.to raise_error(Closed)
+    end
+
+    it "disconnect from server" do
+      shutdown
+      expect { loop.run }.to raise_error(Closed)
+    end
+  end
+  
+  context "#on_read" do
+    class Finished < StandardError; end
+    class OnRead < Cool.io::TCPSocket
+      attr :read_data, :times
+      def on_connect
+        @read_data = ""
+        @times = 0
+      end
+      def on_read(data)
+        @read_data += data
+        @times += 1
+        if @times < 5
+          write "#{@times}"
+        else
+          close
+          raise Finished
+        end
+      end
+    end
+    
+    it "receive 5 times" do
+      c = OnRead.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "0"
+      expect { loop.run }.to raise_error(Finished)
+      
+      expect(c.times).to eq 5
+      expect(c.read_data).to eq "01234"
+    end
+  end
+  
+  context "#on_write_complete" do
+    class WriteComplete < StandardError; end
+    class OnWriteComplete < Cool.io::TCPSocket
+      attr :called
+      def on_write_complete
+        @called = true
+        close
+        raise WriteComplete
+      end
+    end
+    
+    it "on_write_complete is called" do
+      c = OnWriteComplete.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "aaa"
+      expect { loop.run }.to raise_error(WriteComplete)
+    end
+  end
+end

data/spec/timer_watcher_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cool.io::TimerWatcher do
+
+  interval = 0.010
+
+  let :loop do
+    Cool.io::Loop.new
+  end
+
+  it "can have the on_timer callback defined after creation" do
+    @watcher = Cool.io::TimerWatcher.new(interval, true)
+    nr = '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
+    sleep interval
+    loop.run_once
+    expect(nr).to eq('1')
+  end
+
+  it "can be subclassed" do
+    class MyTimerWatcher < Cool.io::TimerWatcher
+      TMP = '0'
+
+      def on_timer
+        TMP.succ!
+      end
+    end
+    @watcher = MyTimerWatcher.new(interval, true)
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(MyTimerWatcher::TMP).to eq('0')
+    sleep interval
+    loop.run_once
+    expect(MyTimerWatcher::TMP).to eq('1')
+  end
+
+  it "can have the on_timer callback redefined between runs" do
+    @watcher = Cool.io::TimerWatcher.new(interval, true)
+    nr = '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
+    sleep interval
+    loop.run_once
+    expect(nr).to eq('1')
+    @watcher.detach
+    expect(@watcher.on_timer { nr = :foo }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('1')
+    sleep interval
+    loop.run_once
+    expect(nr).to eq(:foo)
+  end
+
+  after :each do
+    @watcher.detach if defined?(@watcher)
+  end
+end

data/spec/udp_socket_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Coolio::UDPSocket" do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = UDPSocket.open
+    @echo.bind nil, 0
+    @port = @echo.addr[1]
+    
+    @running = true
+    @echo_thread = Thread.new do
+      while @running
+        begin
+          msg, sender = @echo.recvfrom_nonblock(3)
+          @echo.send(msg + "bbb", 0, sender[3], sender[1])
+        rescue IO::WaitReadable
+        end
+        Thread.pass
+      end
+    end
+  end
+  
+  after :each do
+    @running = false
+    @echo_thread.join
+    @echo.close
+  end
+  
+  class Readable < Cool.io::IOWatcher
+    attr :socket, :received
+    def initialize
+      @socket = UDPSocket.new
+      super(@socket)
+    end
+    
+    def on_readable
+      @received = @socket.recvfrom_nonblock(6).first
+    end
+  end
+  
+  it "receive message #on_readable 5 times" do
+    5.times do
+      begin
+        r = Readable.new
+        r.socket.send "aaa", 0, "localhost", @port
+        
+        loop.attach r
+        loop.run_once
+        expect(r.received).to eq "aaabbb"
+      ensure
+        r.detach
+      end
+    end
+  end
+end

data/spec/unix_listener_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tempfile'
+
+describe Cool.io::UNIXListener, :env => :exclude_win do
+
+  before :each do
+    @tmp = Tempfile.new('coolio_unix_listener_spec')
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
+  end
+
+  it "creates a new UNIXListener" do
+    listener = Cool.io::UNIXListener.new(@tmp.path)
+    expect(File.socket?(@tmp.path)).to eq(true)
+  end
+
+  it "builds off an existing UNIXServer" do
+    unix_server = UNIXServer.new(@tmp.path)
+    expect(File.socket?(@tmp.path)).to eq(true)
+    listener = Cool.io::UNIXListener.new(unix_server)
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
+  end
+
+end

data/spec/unix_server_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tempfile'
+
+describe Cool.io::UNIXServer, :env => :exclude_win do
+
+  before :each do
+    @tmp = Tempfile.new('coolio_unix_server_spec')
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
+  end
+
+  it "creates a new Cool.io::UNIXServer" do
+    listener = Cool.io::UNIXListener.new(@tmp.path)
+    listener.listen(24)
+    expect(File.socket?(@tmp.path)).to eq(true)
+  end
+
+  it "builds off an existing ::UNIXServer" do
+    unix_server = ::UNIXServer.new(@tmp.path)
+    expect(File.socket?(@tmp.path)).to eq(true)
+    listener = Cool.io::UNIXServer.new(unix_server, Coolio::UNIXSocket)
+    listener.listen(24)
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
+  end
+
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: cool.io
+version: !ruby/object:Gem::Version
+  version: 1.4.1
+platform: x64-mingw32
+authors:
+- Tony Arcieri
+- Masahiro Nakagawa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+description: Cool.io provides a high performance event framework for Ruby which uses
+  the libev C library
+email:
+- tony.arcieri@gmail.com
+- repeatedly@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cool.io.gemspec
+- examples/callbacked_echo_server.rb
+- examples/dslified_echo_client.rb
+- examples/dslified_echo_server.rb
+- examples/echo_client.rb
+- examples/echo_server.rb
+- examples/google.rb
+- ext/cool.io/.gitignore
+- ext/cool.io/cool.io.h
+- ext/cool.io/cool.io_ext.c
+- ext/cool.io/ev_wrap.h
+- ext/cool.io/extconf.rb
+- ext/cool.io/iowatcher.c
+- ext/cool.io/libev.c
+- ext/cool.io/loop.c
+- ext/cool.io/stat_watcher.c
+- ext/cool.io/timer_watcher.c
+- ext/cool.io/utils.c
+- ext/cool.io/watcher.c
+- ext/cool.io/watcher.h
+- ext/iobuffer/extconf.rb
+- ext/iobuffer/iobuffer.c
+- ext/libev/Changes
+- ext/libev/LICENSE
+- ext/libev/README
+- ext/libev/README.embed
+- ext/libev/ev.c
+- ext/libev/ev.h
+- ext/libev/ev_epoll.c
+- ext/libev/ev_kqueue.c
+- ext/libev/ev_poll.c
+- ext/libev/ev_port.c
+- ext/libev/ev_select.c
+- ext/libev/ev_vars.h
+- ext/libev/ev_win32.c
+- ext/libev/ev_wrap.h
+- ext/libev/ruby_gil.patch
+- ext/libev/test_libev_win32.c
+- ext/libev/win_select.patch
+- lib/.gitignore
+- lib/2.0/cool.io_ext.so
+- lib/2.0/iobuffer_ext.so
+- lib/2.1/cool.io_ext.so
+- lib/2.1/iobuffer_ext.so
+- lib/2.2/cool.io_ext.so
+- lib/2.2/iobuffer_ext.so
+- lib/cool.io.rb
+- lib/cool.io/async_watcher.rb
+- lib/cool.io/custom_require.rb
+- lib/cool.io/dns_resolver.rb
+- lib/cool.io/dsl.rb
+- lib/cool.io/io.rb
+- lib/cool.io/iowatcher.rb
+- lib/cool.io/listener.rb
+- lib/cool.io/loop.rb
+- lib/cool.io/meta.rb
+- lib/cool.io/server.rb
+- lib/cool.io/socket.rb
+- lib/cool.io/timer_watcher.rb
+- lib/cool.io/version.rb
+- lib/coolio.rb
+- spec/async_watcher_spec.rb
+- spec/dns_spec.rb
+- spec/iobuffer_spec.rb
+- spec/spec_helper.rb
+- spec/stat_watcher_spec.rb
+- spec/tcp_server_spec.rb
+- spec/tcp_socket_spec.rb
+- spec/timer_watcher_spec.rb
+- spec/udp_socket_spec.rb
+- spec/unix_listener_spec.rb
+- spec/unix_server_spec.rb
+homepage: http://coolio.github.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- 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.4.8
+signing_key: 
+specification_version: 4
+summary: A cool framework for doing high performance I/O in Ruby
+test_files: []