cool.io 1.4.1-x64-mingw32

data/lib/cool.io/timer_watcher.rb

@@ -0,0 +1,17 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  class TimerWatcher
+    # The actual implementation of this class resides in the C extension
+    # Here we metaprogram proper event_callbacks for the callback methods
+    # These can take a block and store it to be called when the event
+    # is actually fired.
+
+    extend Meta
+    event_callback :on_timer
+  end
+end

data/lib/cool.io/version.rb

@@ -0,0 +1,7 @@
+module Coolio
+  VERSION = "1.4.1"
+  
+  def self.version
+    VERSION
+  end
+end

data/lib/coolio.rb

@@ -0,0 +1,2 @@
+# For those people who don't like the cool.io styling...
+require 'cool.io'

data/spec/async_watcher_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tempfile'
+require 'fcntl'
+
+describe Cool.io::AsyncWatcher, :env => :exclude_win do
+
+  it "does not signal on spurious wakeups" do
+    aw = Cool.io::AsyncWatcher.new
+    tmp = Tempfile.new('coolio_async_watcher_test')
+    nr_fork = 2 # must be at least two for spurious wakeups
+
+    # We have aetter chance of failing if this overflows the pipe buffer
+    # which POSIX requires >= 512 bytes, Linux 2.6 uses 4096 bytes
+    nr_signal = 4096 * 4
+
+    append = File.open(tmp.path, "ab")
+    append.sync = true
+    rd, wr = ::IO.pipe
+
+    aw.on_signal { append.syswrite("#$$\n") }
+    children = nr_fork.times.map do
+      fork do
+        trap(:TERM) { exit!(0) }
+        rloop = Cool.io::Loop.default
+        aw.attach(rloop)
+        wr.write '.' # signal to master that we're ready
+        rloop.run
+        exit!(1) # should not get here
+      end
+    end
+
+    # ensure children are ready
+    nr_fork.times { expect(rd.sysread(1)).to eq('.') }
+
+    # send our signals
+    nr_signal.times { aw.signal }
+
+    # wait for the pipe buffer to be consumed by the children
+    sleep 1 while tmp.stat.ctime >= (Time.now - 4)
+
+    children.each do |pid|
+      Process.kill(:TERM, pid)
+      _, status = Process.waitpid2(pid)
+      expect(status.exitstatus).to eq(0)
+    end
+
+    # we should've written a line for every signal we sent
+    lines = tmp.readlines
+    expect(lines.size).to eq(nr_signal)
+
+    # theoretically a bad kernel scheduler could give us fewer...
+    expect(lines.sort.uniq.size).to eq(nr_fork)
+
+    tmp.close!
+  end
+
+end

data/spec/dns_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+VALID_DOMAIN = "google.com"
+INVALID_DOMAIN = "gibidigibigididibitidibigitibidigitidididi.com"
+
+class ItWorked < StandardError; end
+class WontResolve < StandardError; end
+
+class ConnectorThingy < Cool.io::TCPSocket
+  def on_connect
+    raise ItWorked
+  end
+
+  def on_resolve_failed
+    raise WontResolve
+  end
+end
+
+describe "DNS" do
+  before :each do
+    @loop = Cool.io::Loop.new
+  end
+  
+  it "connects to valid domains" do
+    begin
+      c = ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
+      
+      expect do
+        @loop.run
+      end.to raise_error(ItWorked)
+    ensure
+      c.close
+    end
+  end
+  
+  it "fires on_resolve_failed for invalid domains" do
+    ConnectorThingy.connect(INVALID_DOMAIN, 80).attach(@loop)
+    
+    expect do
+      @loop.run
+    end.to raise_error(WontResolve)
+  end
+end

data/spec/iobuffer_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+
+describe IO::Buffer do
+
+  let :buffer do
+    IO::Buffer.new
+  end
+  
+  it "provides a subset of the methods available in Strings" do
+    expect(buffer << "foo").to eq "foo"
+    expect(buffer << "bar").to eq "bar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.size).to eq 6
+  end
+
+  it "provides append and prepend" do
+    expect(buffer.append "bar").to eq "bar"
+    expect(buffer.prepend "foo").to eq "foo"
+    expect(buffer.append "baz").to eq "baz"
+    expect(buffer.to_str).to eq "foobarbaz"
+  end
+  
+  context "#read" do
+    it "can be used to retrieve the contents of a buffer" do
+      expect(buffer << "foo").to eq "foo"
+      expect(buffer.read 2).to eq "fo"
+      expect(buffer << "bar").to eq "bar"
+      expect(buffer.read 2).to eq "ob"
+      expect(buffer << "baz").to eq "baz"
+      expect(buffer.read 3).to eq "arb"
+    end
+  end
+  
+  describe "provides methods for performing non-blocking I/O" do
+    require "tempfile"
+    
+    context "#read_from" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          t = Tempfile.open "read_from"
+          t << "foobar"
+          t.rewind
+          t
+        end
+        
+        it "will read as much data as possible" do
+          expect(buffer.read_from tmp).to eq 6
+          expect(buffer.to_str).to eq "foobar"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          select [], [@sender]
+          @sender.send "foo", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 3
+          expect(buffer.to_str).to eq "foo"
+          
+          select [], [@sender]
+          @sender.send "barbaz", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 6
+          expect(buffer.to_str).to eq "foobarbaz"
+        end
+      end
+    end
+    
+    context "#write_to" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          Tempfile.open "write_to"
+        end
+        it "writes the contents of the buffer" do
+          buffer << "foo"
+          expect(buffer.write_to tmp).to eq 3
+          tmp.rewind
+          expect(tmp.read 3).to eq "foo"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          buffer << "foo"
+          select [], [@sender]
+          expect(buffer.write_to @sender).to eq 3
+          select [@receiver]
+          expect(@receiver.recvfrom_nonblock(3)[0]).to eq "foo"
+        end
+      end
+    end
+  end
+  
+  context "#clear" do
+    it "clear all data" do
+      buffer << "foo"
+      expect(buffer.size).to eq 3
+      expect(buffer.empty?).to eq false
+      buffer.clear
+      expect(buffer.size).to eq 0
+      expect(buffer.empty?).to eq true
+    end
+  end
+  
+  context "#read_frame" do
+    it "Read up to and including the given frame marker" do
+      buffer << "foo\nbarbaz"
+      data = ""
+      expect(buffer.read_frame data, "\n".ord).to eq true
+      expect(buffer.empty?).to eq false
+      expect(data).to eq "foo\n"
+      expect(buffer.to_str).to eq "barbaz"
+      
+      expect(buffer.read_frame data, "\n".ord).to eq false
+      expect(buffer.empty?).to eq true
+      expect(data).to eq "foo\nbarbaz"
+      expect(buffer.to_str).to eq ""
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'cool.io'
+
+def unused_port
+  s = TCPServer.open(0)
+  port = s.addr[1]
+  s.close
+  port
+end
+
+RSpec.configure do |c|
+  if RUBY_PLATFORM =~ /mingw|mswin/
+    $stderr.puts "Skip some specs on Windows"
+    c.filter_run_excluding :env => :exclude_win
+  end
+end

data/spec/stat_watcher_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TEMP_FILE_PATH = "./test.txt"
+
+INTERVAL = 0.010
+
+class MyStatWatcher < Cool.io::StatWatcher
+  attr_accessor :accessed, :previous, :current
+
+  def initialize(path)
+    super path, INTERVAL
+  end
+
+  def on_change(previous, current)
+    self.accessed = true
+    self.previous = previous
+    self.current  = current
+  end
+end
+
+def run_with_file_change(path)
+  reactor = Cool.io::Loop.new
+
+  sw = MyStatWatcher.new(path)
+  sw.attach(reactor)
+
+  tw = Cool.io::TimerWatcher.new(INTERVAL, true)
+  tw.on_timer do
+    reactor.stop if sw.accessed
+    write_file(path)
+  end
+  tw.attach(reactor)
+
+  reactor.run
+
+  tw.detach
+  sw.detach
+
+  sw
+end
+
+def write_file(path)
+  File.open(path, "w+") { |f| f.write(rand.to_s) }
+end
+
+def delete_file(path)
+  File.delete(TEMP_FILE_PATH)
+end
+
+describe Cool.io::StatWatcher do
+
+  let :watcher do
+    run_with_file_change(TEMP_FILE_PATH)
+  end
+
+  before :each do
+    write_file(TEMP_FILE_PATH)
+  end
+
+  after :each do
+    delete_file(TEMP_FILE_PATH)
+  end
+
+  it "fire on_change when the file it is watching is modified" do
+    expect(watcher.accessed).to eq(true)
+  end
+
+  it "should pass previous and current file stat info given a stat watcher" do
+    expect(watcher.previous.ino).to eq(watcher.current.ino)
+  end
+
+  it "should raise when the handler does not take 2 parameters" do
+    class MyStatWatcher < Cool.io::StatWatcher; def on_change; end; end
+    expect { watcher.accessed }.to raise_error(ArgumentError)
+  end
+
+end

data/spec/tcp_server_spec.rb

@@ -0,0 +1,225 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TIMEOUT = 0.010
+HOST = '127.0.0.1'
+PORT = unused_port
+
+def send_data(data)
+  io = TCPSocket.new('127.0.0.1', PORT)
+  begin
+    io.write data
+  ensure
+    io.close
+  end
+end
+
+class MyConnection < Coolio::Socket
+  attr_accessor :data, :connected, :closed
+
+  def initialize(io, on_message)
+    super(io)
+    @on_message = on_message
+  end
+
+  def on_connect
+    @connected = true
+  end
+
+  def on_close
+    @closed = true
+  end
+
+  def on_read(data)
+    @on_message.call(data)
+  end
+end
+
+@data = ""
+def on_message(data)
+  @data = data
+end
+
+def test_run(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new { reactor.run }
+  send_data(data) if data
+  sleep TIMEOUT
+  reactor.stop
+  server.detach
+  send_data('') # to leave from blocking loop
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_once(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new do
+    reactor.run_once # on_connect
+    reactor.run_once # on_read
+  end
+  send_data(data) if data
+  thread.join
+  server.detach
+  @data
+ensure
+  server.close
+end
+
+def test_run_once_timeout(timeout = TIMEOUT)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  running = true
+  thread = Thread.new { reactor.run_once(timeout) }
+  sleep timeout
+  server.detach
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_timeout(data = nil, timeout = TIMEOUT)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  running = true
+  thread = Thread.new do
+    while running and reactor.has_active_watchers?
+      reactor.run_once(timeout)
+    end
+  end
+  send_data(data) if data
+  sleep timeout
+  server.detach
+  running = false # another send is not required
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+# This test should work on Windows
+describe Coolio::TCPServer do
+
+  it '#run' do
+    expect(test_run("hello")).to eq("hello")
+  end
+
+  it '#run_once' do
+    expect(test_run_once("hello")).to eq("hello")
+  end
+
+  it '#run_once(timeout)' do
+    test_run_once_timeout # should not block
+  end
+
+  it '#run_once(-timeout)' do
+    expect { test_run_once_timeout(-0.1) }.to raise_error(ArgumentError)
+  end
+
+  it '#run(timeout)' do
+    expect(test_run_timeout("hello")).to eq("hello")
+  end
+
+  describe "functionaltest" do
+    let :loop do
+      Coolio::Loop.new
+    end
+    
+    let :port do
+      unused_port
+    end
+    
+    context "#on_connect" do
+      class ServerOnConnect < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_connect
+          @cb.call
+        end
+      end
+      
+      it "connected socket called on_connect" do
+        begin
+          connected = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { connected = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          expect(connected).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_close" do
+      class ServerOnClose < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_close
+          @cb.call
+        end
+      end
+      
+      it "closed socket called on_close" do
+        begin
+          closed = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { closed = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          loop.run_once
+          expect(closed).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_read" do
+      class Echo < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_read(data)
+          @cb.call data
+          size = write(data + "fff")
+        end
+      end
+      
+      it "server socket received data" do
+        begin
+          data = "aaa"
+          server = Cool.io::TCPServer.new("localhost", port, Echo, proc { |d| data = d })
+          loop.attach server
+          thread = Thread.new { loop.run }
+          s = TCPSocket.open("localhost", port)
+          s.write "zzz"
+          sleep 0.1
+          expect(data).to eq "zzz"
+          expect(s.read 6).to eq "zzzfff"
+        ensure
+          s.close
+          loop.stop
+          server.detach
+          thread.join
+        end
+      end
+    end
+  end
+end