cool.io 1.9.4 → 1.10.0

data/spec/windows_stat_watcher_spec.rb

@@ -0,0 +1,363 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tmpdir'
+require 'fileutils'
+require 'rbconfig'
+
+describe 'Windows notification-backed StatWatcher', :if => RUBY_PLATFORM =~ /mingw|mswin/ do
+  before do
+    @directory = Dir.mktmpdir('coolio-notify-')
+    @loop = Coolio::Loop.new
+    @watchers = []
+    @threads = []
+  end
+
+  after do
+    @threads.each(&:join)
+    @watchers.each { |watcher| watcher.detach if watcher.attached? }
+    FileUtils.remove_entry(@directory)
+    @loop = nil
+    @watchers = nil
+    GC.start # exercise IOCP cancellation and loop destruction
+  end
+
+  def watch(path, interval = 60)
+    watcher = Coolio::StatWatcher.new(path, interval)
+    watcher.attach(@loop)
+    @watchers << watcher
+    watcher
+  end
+
+  def root_file
+    path = File.join(File.expand_path('/'), "coolio-#{File.basename(@directory)}")
+    begin
+      File.write(path, 'a')
+    rescue Errno::EACCES, Errno::EPERM, Errno::EROFS
+      skip 'requires write access to the drive root'
+    end
+    path
+  end
+
+  # With a 60-second stat interval, a callback within this deadline must come
+  # from native notifications. Mutate from another thread while select waits.
+  def await_change(watcher, size: nil, exists: nil, &mutation)
+    change = nil
+    first_previous = nil
+    reactor = @loop
+    callback_thread = nil
+    stopped = false
+    stop = -> do
+      unless stopped
+        stopped = true
+        reactor.stop
+      end
+    end
+    watcher.define_singleton_method(:on_change) do |previous, current|
+      first_previous ||= previous
+      if (size.nil? || current.size == size) && (exists.nil? || (current.nlink != 0) == exists)
+        change = [first_previous, current]
+        callback_thread = Thread.current
+        stop.call
+      end
+    end
+    deadline = Coolio::TimerWatcher.new(2, false)
+    deadline.on_timer { stop.call }
+    deadline.attach(@loop)
+    @threads << Thread.new { sleep 0.1; mutation.call }
+    @loop.run
+    expect(change).not_to be_nil
+    expect(callback_thread).to eq(Thread.current)
+    change
+  ensure
+    deadline.detach if deadline && deadline.attached?
+    @threads.each(&:join)
+  end
+
+  it 'wakes a blocked loop for a file size change without waiting for polling' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    previous, current = await_change(watch(path), size: 6) { File.write(path, 'longer') }
+    expect(previous.size).to eq(1)
+    expect(current.size).to eq(6)
+  end
+
+  it 'notifies for creation, deletion, and recreation of a watched file' do
+    path = File.join(@directory, 'file')
+    watcher = watch(path)
+    previous, current = await_change(watcher, size: 7, exists: true) { File.write(path, 'created') }
+    expect(previous.nlink).to eq(0)
+    expect(current.nlink).not_to eq(0)
+    _, current = await_change(watcher, exists: false) { File.delete(path) }
+    expect(current.nlink).to eq(0)
+    _, current = await_change(watcher, size: 9, exists: true) { File.write(path, 'recreated') }
+    expect(current.size).to eq(9)
+  end
+
+  it 'notifies when a watched file is renamed away' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    _, current = await_change(watch(path)) { File.rename(path, "#{path}.old") }
+    expect(current.nlink).to eq(0)
+  end
+
+  it 'supports Unicode parent directories and filenames' do
+    directory = File.join(@directory, "\u76e3\u8996")
+    Dir.mkdir(directory)
+    path = File.join(directory, "\u5909\u66f4.txt")
+    File.write(path, 'a')
+    _, current = await_change(watch(path), size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'matches notification names using Windows Unicode case folding' do
+    path = File.join(@directory, "\u00c4.txt")
+    File.write(path, 'a')
+    folded = File.join(@directory, "\u00e4.txt")
+    skip 'requires a case-insensitive directory' unless File.exist?(folded)
+    watcher = watch(folded)
+    _, current = await_change(watcher, size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'notifies for an extended-length file path below a directory' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    extended = "\\\\?\\#{path.tr('/', '\\')}"
+    _, current = await_change(watch(extended), size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'notifies for an extended-length file path at the drive root' do
+    path = root_file
+    extended = "\\\\?\\#{path.tr('/', '\\')}"
+    _, current = await_change(watch(extended), size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  ensure
+    File.delete(path) if path && File.exist?(path)
+  end
+
+  it 'notifies for an extended-length drive root directory' do
+    path = root_file
+    child = "#{path}.child"
+    root = "\\\\?\\#{File.expand_path('/').tr('/', '\\')}"
+    watcher = watch(root)
+    sleep 1.1 # Directory timestamps are exposed as whole seconds.
+    await_change(watcher) { File.write(child, 'a') }
+  ensure
+    [path, child].compact.each { |file| File.delete(file) if File.exist?(file) }
+  end
+
+  it 'continues monitoring a shared directory after another watcher detaches' do
+    first = File.join(@directory, 'first')
+    second = File.join(@directory, 'second')
+    File.write(first, 'a')
+    File.write(second, 'a')
+    first_watcher = watch(first)
+    second_watcher = watch(second)
+    first_watcher.detach
+    _, current = await_change(second_watcher, size: 6) { File.write(second, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'transcodes a Windows-31J path for the wide Windows APIs' do
+    path = File.join(@directory, "\u5909\u66f4.txt")
+    File.write(path, 'a')
+    watcher = watch(path.encode('Windows-31J'))
+    _, current = await_change(watcher, size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'transfers notification monitoring to another loop' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    watcher = watch(path)
+    old_loop = @loop
+    @loop = Coolio::Loop.new
+    watcher.attach(@loop)
+    old_loop.run_nonblock
+    _, current = await_change(watcher, size: 6) { File.write(path, 'longer') }
+    expect(current.size).to eq(6)
+  end
+
+  it 'does not dispatch a queued change after disable and supports re-enable' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    watcher = watch(path)
+    calls = 0
+    watcher.define_singleton_method(:on_change) { |_, _| calls += 1 }
+    File.write(path, 'queued')
+    sleep 0.05
+    watcher.disable
+    @loop.run_nonblock
+    expect(calls).to eq(0)
+    watcher.enable
+    _, current = await_change(watcher, size: 12) { File.write(path, 'after enable') }
+    expect(current.size).to eq(12)
+  end
+
+  it 'falls back to polling when the parent is missing, then registers notifications' do
+    directory = File.join(@directory, 'missing')
+    path = File.join(directory, 'file')
+    watcher = watch(path, 0.1)
+    _, current = await_change(watcher, size: 7, exists: true) { Dir.mkdir(directory); File.write(path, 'created') }
+    expect(current.size).to eq(7)
+    # Reattach with a long interval to prove the now-existing parent is watched.
+    watcher.detach
+    _, current = await_change(watch(path), size: 18) { File.write(path, 'longer than before') }
+    expect(current.size).to eq(18)
+  end
+
+  it 'handles directory entry changes' do
+    directory = File.join(@directory, 'directory')
+    Dir.mkdir(directory)
+    watcher = watch(directory)
+    # StatInfo exposes whole seconds for timestamps; cross a second boundary
+    # so this directory-only change is observable through the existing API.
+    sleep 1.1
+    await_change(watcher) { File.write(File.join(directory, 'child'), 'a') }
+  end
+
+  it 'recovers after a parent directory is moved and replaced' do
+    directory = File.join(@directory, 'parent')
+    Dir.mkdir(directory)
+    path = File.join(directory, 'file')
+    File.write(path, 'a')
+    watcher = watch(path, 0.1)
+    _, current = await_change(watcher, size: 11, exists: true) do
+      File.rename(directory, "#{directory}.old")
+      Dir.mkdir(directory)
+      File.write(path, 'replacement')
+    end
+    expect(current.size).to eq(11)
+    _, current = await_change(watcher, size: 5) { File.write(path, 'final') }
+    expect(current.size).to eq(5)
+  end
+
+  it 'keeps monitoring after an existing file is replaced' do
+    path = File.join(@directory, 'long-watched-filename.log')
+    replacement = File.join(@directory, 'replacement.log')
+    File.write(path, 'a')
+    File.write(replacement, 'replacement')
+    watcher = watch(path)
+    await_change(watcher, size: 11, exists: true) do
+      File.rename(path, "#{path}.old")
+      File.rename(replacement, path)
+    end
+    await_change(watcher, size: 12) { File.write(path, 'x', mode: 'a') }
+  end
+
+  it 'coalesces a burst of notifications and observes the final state' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    watcher = watch(path)
+    200.times do |index|
+      File.write(path, 'x' * (index + 2))
+    end
+    _, current = await_change(watcher, size: 5) { File.write(path, 'final') }
+    expect(current.size).to eq(5)
+  end
+
+  it 'validates a shared directory handle before attaching a new watcher' do
+    directory = File.join(@directory, 'parent')
+    Dir.mkdir(directory)
+    first = File.join(directory, 'first')
+    File.write(first, 'a')
+    watch(first)
+
+    File.rename(directory, "#{directory}.old")
+    Dir.mkdir(directory)
+    second = File.join(directory, 'second')
+    File.write(second, 'a')
+    _, current = await_change(watch(second), size: 5) { File.write(second, 'final') }
+    expect(current.size).to eq(5)
+  end
+
+  it 'keeps timers and Ruby threads responsive during sustained notifications' do
+    observed_size = nil
+    paths = 1000.times.map do |index|
+      path = File.join(@directory, "#{index}.log")
+      File.write(path, 'a')
+      watch(path).define_singleton_method(:on_change) do |_, current|
+        observed_size = current.size if index.zero?
+      end
+      path
+    end
+    clock = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+    timer_gaps = []
+    thread_gaps = []
+    child = status = final_size = previous = deadline_at = nil
+    timer = Coolio::TimerWatcher.new(0.1, true)
+    timer.on_timer do
+      now = clock.call
+      timer_gaps << now - previous
+      previous = now
+      if child && (result = Process.wait2(child, Process::WNOHANG))
+        _, status = result
+        child = nil
+        final_size = File.size(paths.first)
+      end
+      # Process startup and notification delivery can outlast a fixed window
+      # on CI. Keep dispatching until the writer exits and its final size arrives.
+      @loop.stop if (status && observed_size == final_size) || now >= deadline_at
+    end
+    timer.attach(@loop)
+    @watchers << timer
+    done = false
+    # Use a separate process: a Ruby writer thread would itself be blocked by
+    # the GVL while the notification callback is draining the dirty set.
+    writer = <<~'RUBY'
+      path = ARGV.fetch(0)
+      sleep 0.3
+      clock = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+      start = clock.call
+      writes = 0
+      while clock.call - start < 3
+        File.write(path, 'x', mode: 'a')
+        writes += 1
+        sleep [start + writes.fdiv(64) - clock.call, 0].max
+      end
+    RUBY
+    child = Process.spawn(RbConfig.ruby, '-e', writer, paths.first)
+    @threads << Thread.new do
+      last = clock.call
+      until done
+        sleep 0.05
+        now = clock.call
+        thread_gaps << now - last
+        last = now
+      end
+    end
+    previous = clock.call
+    deadline_at = previous + 15
+    @loop.run
+    done = true
+    @threads.each(&:join)
+    expect(status).not_to be_nil
+    expect(status.success?).to eq(true)
+    expect(timer_gaps.max).to be < 2
+    expect(thread_gaps.max).to be < 2
+    expect(final_size).to be > 1
+    expect(observed_size).to eq(final_size)
+  ensure
+    done = true
+    if child
+      begin
+        Process.kill('KILL', child)
+      rescue Errno::ESRCH
+      end
+      Process.wait(child)
+    end
+  end
+
+  it 'can repeatedly detach and reattach while changes are pending' do
+    path = File.join(@directory, 'file')
+    File.write(path, 'a')
+    watcher = watch(path)
+    50.times do |index|
+      File.write(path, 'x' * (index + 2))
+      watcher.detach
+      watcher.attach(@loop)
+    end
+    _, current = await_change(watcher, size: 5) { File.write(path, 'final') }
+    expect(current.size).to eq(5)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.9.4
+  version: 1.10.0
 platform: ruby
 authors:
 - Tony Arcieri
@@ -77,6 +77,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/workflows/test.yaml"
+- ".github/workflows/valgrind.yaml"
 - ".gitignore"
 - ".rspec"
 - CHANGES.md
@@ -118,6 +119,7 @@ files:
 - ext/libev/ev_select.c
 - ext/libev/ev_vars.h
 - ext/libev/ev_win32.c
+- ext/libev/ev_win32_stat.c
 - ext/libev/ev_wrap.h
 - ext/libev/test_libev_win32.c
 - gems.rb
@@ -142,7 +144,9 @@ files:
 - spec/async_watcher_spec.rb
 - spec/detach_race_condition_spec.rb
 - spec/dns_spec.rb
+- spec/fixtures/windows_stat_native.c
 - spec/iobuffer_spec.rb
+- spec/loop_spec.rb
 - spec/spec_helper.rb
 - spec/stat_watcher_spec.rb
 - spec/tcp_server_spec.rb
@@ -151,6 +155,9 @@ files:
 - spec/udp_socket_spec.rb
 - spec/unix_listener_spec.rb
 - spec/unix_server_spec.rb
+- spec/watcher_reattach_spec.rb
+- spec/windows_stat_native_spec.rb
+- spec/windows_stat_watcher_spec.rb
 homepage: https://github.com/socketry/cool.io
 licenses:
 - MIT
@@ -169,14 +176,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files:
 - spec/async_watcher_spec.rb
 - spec/detach_race_condition_spec.rb
 - spec/dns_spec.rb
+- spec/fixtures/windows_stat_native.c
 - spec/iobuffer_spec.rb
+- spec/loop_spec.rb
 - spec/spec_helper.rb
 - spec/stat_watcher_spec.rb
 - spec/tcp_server_spec.rb
@@ -185,3 +194,6 @@ test_files:
 - spec/udp_socket_spec.rb
 - spec/unix_listener_spec.rb
 - spec/unix_server_spec.rb
+- spec/watcher_reattach_spec.rb
+- spec/windows_stat_native_spec.rb
+- spec/windows_stat_watcher_spec.rb