polyphony 0.67 → 0.68

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b8553a2f84e79520ce53412ee6891873c9a9d25e0789e82b26a7153d3d7ae67
-  data.tar.gz: 6889ef71f11d79d6fbb82adc77447f9b3526a29858f2aa3c9e51ee9098add2c7
+  metadata.gz: d23a9c0f60530fdee1d367f34359e4f694bd4a42ba3c0112e61433df05c29a81
+  data.tar.gz: bf75e3f1a633f5c94a43fd45a2de2545d87b1e751753980abb8e1d3eddd4eade
 SHA512:
-  metadata.gz: 91814f767f74c673681a2215f82a302f3aab5ced6ae7197720e474b8c1ad6846eb10001580c1f11d5b62bd0ed7563422fd71f0fb5728eb0b3fcb4ebd36d2038c
-  data.tar.gz: 74e1c7ed34b4f212ca1ffd5881da3e9f689c3934d0f3680da2396d7444b5a214a610ccc779c1ef59713116f0a8240491dc60f32b5d5e30de5092ddc41b8c9f18
+  metadata.gz: b810c7ddbd383039e5f34fe76dbea089807417d4415e79a952f6d6a46538cf99c55ae7a34f3eadf61d22af23ac29a0910c62ea5c97dff6e86b94083d98444edf
+  data.tar.gz: '063459edd8f669a024e0b7b8f1daa47983db4cf9ac7f3ca81a69359de92eace4831d843e9b74645db08a50c26d83a2878a5fdb6b125adc260afd13a3135e710c'

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.68 2021-08-13
+
+- Fix missing default value in socket classes' `#readpartial`
+- Fix linking of operations in `Backend#chain` (io_uring version)
+- Rename `Fiber#attach` to `Fiber#attach_to`
+- Expose original `SSLServer#accept`
+
 ## 0.67 2021-08-06
 
 - Improve fiber monitoring

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.67)
+    polyphony (0.68)
 
 GEM
   remote: https://rubygems.org/

data/bin/pdbg

@@ -8,23 +8,105 @@ UNIX_SOCKET_PATH = '/tmp/pdbg.sock'
 
 cmd = ARGV.join(' ')
 injected_lib_path = File.expand_path('../lib/polyphony/debugger/server_inject.rb', __dir__)
-p cmd
 pid = fork { exec("env POLYPHONY_DEBUG_SOCKET_PATH=#{UNIX_SOCKET_PATH} ruby #{cmd}") }
 puts "Started debugged process (#{pid})"
 
-sleep 3
-socket = UNIXSocket.new(UNIX_SOCKET_PATH)
+socket = nil
+while !socket
+  socket = UNIXSocket.new(UNIX_SOCKET_PATH) rescue nil
+end
+
+def parse_command(cmd)
+  case cmd
+  when /^(step|s)$/
+    { cmd: :step }
+  when /^(state|st)$/
+    { cmd: :state }
+  when /^(help|h)$/
+    { cmd: :help }
+  when /^(list|l)$/
+    { cmd: :list }
+  else
+    nil
+  end
+end
+
+def display_info(info)
+  info = eval(info)
+  case (info && info[:kind])
+  when :listing
+    print_listing(info)
+  when :state
+    print_state(info)
+  else
+    p info
+  end
+rescue SyntaxError
+  puts "Failed to eval:"
+  p info
+end
+
+FILE_LINES_CACHE = {}
+
+def self.get_snippet(path, lineno)
+  lines = FILE_LINES_CACHE[path] ||= IO.read(path).lines
+  start_idx = lineno - 5
+  stop_idx = lineno + 3
+  stop_idx = lines.size - 1 if stop_idx >= lines.size
+  start_idx = 0 if start_idx < 0
+  (start_idx..stop_idx).map { |idx| [idx + 1, lines[idx]]}
+end
+
+def print_snippet(info, snippet, cur_line)
+  places = FILE_LINES_CACHE[info[:path]].size.to_s.size
+  snippet.each do |(lineno, line)|
+    is_cur = lineno == cur_line
+    formatted = format("%s% #{places}d %s", is_cur ? '=> ' : '   ', lineno, line)
+    puts formatted
+  end
+end
+
+def print_listing(info)
+  snippet = get_snippet(info[:path], info[:lineno])
+  puts "Fiber: #{info[:fiber]} Location: #{info[:path]}:#{info[:lineno]}"
+  puts
+  print_snippet(info, snippet, info[:lineno])
+  puts
+end
+
+def print_help
+  puts
+  puts "Here's some help..."
+  puts
+end
+
+def print_state(info)
+  p info
+end
+
+def get_user_cmd
+  while true
+    STDOUT << "(pdbg) "
+    cmd = parse_command(STDIN.gets)
+    next unless cmd
+    
+    if cmd[:cmd] == :help
+      print_help
+    else
+      return cmd if cmd
+    end
+  end
+end
+
 socket.puts 'pdbg'
 response = socket.gets
 if response.chomp == 'pdbg'
   puts 'Connected to process'
 end
 loop do
-  status = socket.gets
-  puts status
+  info = socket.gets.chomp
+  display_info(info)
 
-  STDOUT << "> "
-  cmd = STDIN.gets
-  puts '-' * 40
-  socket.puts cmd
+  cmd = get_user_cmd
+  socket.puts cmd.inspect
 end

data/ext/polyphony/backend_io_uring.c

@@ -1248,7 +1248,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     }
     
     io_uring_sqe_set_data(last_sqe, ctx);
-    unsigned int flags = (i == argc - 1) ? IOSQE_ASYNC : IOSQE_ASYNC & IOSQE_IO_LINK;
+    unsigned int flags = (i == (argc - 1)) ? IOSQE_ASYNC : IOSQE_ASYNC | IOSQE_IO_LINK;
     io_uring_sqe_set_flags(last_sqe, flags);
     sqe_count++;
   }

data/lib/polyphony.rb

@@ -124,6 +124,6 @@ Polyphony.install_at_exit_handler
 
 if (debug_socket_path = ENV['POLYPHONY_DEBUG_SOCKET_PATH'])
   puts "Starting debug server on #{debug_socket_path}"
-  require 'polyphony/debugger/server'
-  Polyphony::DebugServer.start(debug_socket_path)
+  require 'polyphony/debugger'
+  Polyphony.start_debug_server(debug_socket_path)
 end

data/lib/polyphony/debugger.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'polyphony/extensions/debug'
+
+module Polyphony
+  TP_EVENTS = [
+    :line,
+    :call,
+    :return,
+    :b_call,
+    :b_return
+  ]    
+
+  def self.start_debug_server(socket_path)
+    server = DebugServer.new(socket_path)
+    controller = DebugController.new(server)      
+    trace = TracePoint.new(*TP_EVENTS) { |tp| controller.handle_tp(trace, tp) }
+    trace.enable
+
+    at_exit do
+      Kernel.trace "program terminated"
+      trace.disable
+      server.stop
+    end
+  end
+
+  class DebugController
+    def initialize(server)
+      @server = server
+      @server.wait_for_client
+      @state = { fibers: {} }
+      @control_fiber = Fiber.new { |f| control_loop(f) }
+      @control_fiber.transfer Fiber.current
+    end
+
+    def control_loop(source_fiber)
+      @peer = source_fiber
+      cmd = { cmd: :initial }
+      loop do
+        cmd = send(:"cmd_#{cmd[:cmd]}", cmd)
+      end
+    end
+
+    POLYPHONY_LIB_DIR = File.expand_path('..', __dir__)
+
+    def get_next_trace_event
+      @peer.transfer.tap { |e| update_state(e) }
+    end
+
+    def update_state(event)
+      trace update_state: event
+      @state[:fiber] = event[:fiber]
+      @state[:path] = event[:path]
+      @state[:lineno] = event[:lineno]
+      update_fiber_state(event)
+    end
+
+    def update_fiber_state(event)
+      fiber_state = @state[:fibers][event[:fiber]] ||= { stack: [] }
+      case event[:kind]
+      when :call, :c_call, :b_call
+        fiber_state[:stack] << event
+      when :return, :c_return, :b_return
+        fiber_state[:stack].pop
+      end
+      fiber_state[:binding] = event[:binding]
+      fiber_state[:path] = event[:path]
+      fiber_state[:lineno] = event[:lineno]
+    end
+
+    def state_presentation(state)
+      {
+        fiber:  fiber_id(state[:fiber]),
+        path:   state[:path],
+        lineno: state[:lineno]
+      }
+    end
+
+    def fiber_id(fiber)
+      {
+        object_id: fiber.object_id,
+        tag: fiber.tag
+      }
+    end
+
+    def fiber_representation(fiber)
+      {
+        object_id: fiber.object_id,
+        tag: fiber.tag,
+        parent: fiber.parent && fiber_id(fiber.parent),
+        children: fiber.children.map { |c| fiber_id(c) }
+      }
+    end
+
+    def get_next_command(info)
+      @server.get_command(info)
+    end
+
+    def cmd_initial(cmd)
+      get_next_command(nil)
+    end
+
+    def info_listing(state)
+      {
+        kind: :listing,
+        fiber: fiber_id(state[:fiber]),
+        path: state[:path],
+        lineno: state[:lineno]
+      }
+    end
+
+    def info_state(state)
+      info_listing(state).merge(
+        kind: :state,
+        fibers: info_fiber_states(state[:fibers])
+      )
+    end
+
+    def info_fiber_states(fiber_states)
+      fiber_states.inject({}) do |h, (f, s)|
+        h[fiber_id(f)] = {
+          stack: s[:stack].map { |e| { path: e[:path], lineno: e[:lineno] } }
+        }
+        h
+      end
+    end
+    
+    def cmd_step(cmd)
+      tp = nil
+      fiber = nil
+      while true
+        event = get_next_trace_event
+        @peer = event[:fiber]
+        if event[:kind] == :line && event[:path] !~ /#{POLYPHONY_LIB_DIR}/
+          return get_next_command(info_listing(@state))
+        end
+      end
+    rescue => e
+      trace "Uncaught error: #{e.inspect}"
+      @trace&.disable
+    end
+
+    def cmd_help(cmd)
+      get_next_command(kind: :help)
+    end
+
+    def cmd_list(cmd)
+      get_next_command(info_listing(@state))
+    end
+
+    def cmd_state(cmd)
+      get_next_command(info_state(@state))
+    end
+
+    def handle_tp(trace, tp)
+      return if Thread.current == @server.thread
+      return if Fiber.current == @control_fiber
+
+      kind = tp.event
+      event = {
+        fiber: Fiber.current,
+        kind: kind,
+        path: tp.path,
+        lineno: tp.lineno,
+        binding: tp.binding
+      }
+      case kind
+      when :call, :c_call, :b_call
+        event[:method_id] = tp.method_id
+        event[:parameters] = tp.parameters
+      when :return, :c_return, :b_return
+        event[:method_id] = tp.method_id
+        event[:return_value] = tp.return_value
+      end
+      @control_fiber.transfer(event)
+    end
+  end
+
+  class DebugServer
+    attr_reader :thread
+
+    def initialize(socket_path)
+      @socket_path = socket_path
+      @fiber = Fiber.current
+      start_server_thread
+    end
+
+    def start_server_thread
+      @thread = Thread.new do
+        puts("Listening on #{@socket_path}")
+        FileUtils.rm(@socket_path) if File.exists?(@socket_path)
+        socket = UNIXServer.new(@socket_path)
+        loop do
+          @client = socket.accept
+        end
+      end
+    end
+
+    def stop
+      @thread.kill
+    end
+
+    def handle_client(client)
+      @client = client
+    end
+
+    def wait_for_client
+      sleep 0.1 until @client
+      msg = @client.gets
+      @client.puts msg
+    end
+
+    def get_command(info)
+      @client&.orig_write "#{info.inspect}\n"
+      cmd = @client&.orig_gets&.chomp
+      eval(cmd)
+    rescue SystemCallError
+      nil
+    rescue => e
+      trace "Error in interact_with_client: #{e.inspect}"
+      e.backtrace[0..3].each { |l| trace l }
+      @client = nil
+    end
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -79,47 +79,26 @@ module Polyphony
 
   # Fiber supervision
   module FiberSupervision
-    def supervise(opts = {})
-      @counter = 0
-      @on_child_done = proc do |fiber, result|
-        self << fiber unless result.is_a?(Exception)
-      end
-      while true
-        supervise_perform(opts)
-      end
-  rescue Polyphony::MoveOn
-      # generated in #supervise_perform to stop supervisor
-    ensure
-      @on_child_done = nil
-    end
+    def supervise(*fibers, **opts, &block)
+      block ||= opts[:on_done] ||
+                (opts[:on_error] && supervise_on_error_proc(opts[:on_error]))
+      raise "No block given" unless block
 
-    def supervise_perform(opts)
-      fiber = receive
-      if fiber && opts[:restart]
-        restart_fiber(fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
+      fibers.each do |f|
+        f.attach_to(self) unless f.parent == self
+        f.monitor(self)
       end
-    rescue Polyphony::Restart
-      restart_all_children
-    rescue Exception => e
-      Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
 
-      if opts[:restart]
-        restart_fiber(e.source_fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
+      mailbox = monitor_mailbox
+
+      while true
+        (fiber, result) = mailbox.shift
+        block&.call(fiber, result)
       end
     end
 
-    def restart_fiber(fiber, opts)
-      opts[:watcher]&.send [:restart, fiber]
-      case opts[:restart]
-      when true
-        fiber.restart
-      when :one_for_all
-        @children.keys.each(&:restart)
-      end
+    def supervise_on_error_proc(on_error)
+      ->(f, r) { opts[:on_error].(f, r) if r.is_a?(Exception) }
     end
   end
 
@@ -261,10 +240,17 @@ module Polyphony
       @parent.add_child(self)
     end
 
-    def attach(parent)
+    def attach_to(fiber)
       @parent.remove_child(self)
-      @parent = parent
-      @parent.add_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+    end
+
+    def attach_and_monitor(fiber)
+      @parent.remove_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+      monitor(fiber)
     end
   end
 

data/lib/polyphony/extensions/io.rb

@@ -160,8 +160,6 @@ class ::IO
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
       result = readpartial(8192, @read_buffer, -1)
-        
-      #Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
       return nil unless result
     end
   rescue EOFError

data/lib/polyphony/extensions/openssl.rb

@@ -114,6 +114,68 @@ end
 
 # OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
 class ::OpenSSL::SSL::SSLServer
+  attr_reader :ctx
+
+  alias_method :orig_accept, :accept
+  def accept
+    # when @ctx.servername_cb is set, we use a worker thread to run the
+    # ssl.accept call. We need to do this because:
+    # - We cannot switch fibers inside of the servername_cb proc (see
+    #   https://github.com/ruby/openssl/issues/415)
+    # - We don't want to stop the world while we're busy provisioning an ACME
+    #   certificate
+    if @use_accept_worker.nil?
+      if (@use_accept_worker = use_accept_worker_thread?)
+        start_accept_worker_thread
+      end
+    end
+
+    sock, = @svr.accept
+    begin
+      ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+      ssl.sync_close = true
+      if @use_accept_worker
+        @accept_worker_fiber << [ssl, Fiber.current]
+        receive
+      else
+        ssl.accept
+      end
+      ssl
+    rescue Exception => ex
+      if ssl
+        ssl.close
+      else
+        sock.close
+      end
+      raise ex
+    end
+  end
+
+  def start_accept_worker_thread
+    fiber = Fiber.current
+    @accept_worker_thread = Thread.new do
+      fiber << Fiber.current
+      loop do
+        socket, peer = receive
+        socket.accept
+        peer << socket
+      rescue => e
+        peer.schedule(e) if fiber
+      end
+    end
+    @accept_worker_fiber = receive
+  end
+
+  def use_accept_worker_thread?
+    !!@ctx.servername_cb
+  end
+
+  alias_method :orig_close, :close
+  def close
+    @accept_worker_thread&.kill
+    orig_close
+  end
+
   def accept_loop(ignore_errors = true)
     loop do
       yield accept

data/lib/polyphony/extensions/socket.rb

@@ -206,7 +206,7 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
     result
@@ -299,7 +299,7 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
     result

data/lib/polyphony/net.rb

@@ -67,6 +67,7 @@ module Polyphony
       def setup_alpn(context, protocols)
         context.alpn_protocols = protocols
         context.alpn_select_cb = lambda do |peer_protocols|
+          p alpn_select_cb: peer_protocols
           (protocols & peer_protocols).first
         end
       end

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.67'
+  VERSION = '0.68'
 end

data/test/helper.rb

@@ -47,7 +47,6 @@ class MiniTest::Test
   def setup
     # trace "* setup #{self.name}"
     Fiber.current.setup_main_fiber
-    Fiber.current.instance_variable_set(:@auto_watcher, nil)
     Thread.current.backend.finalize
     Thread.current.backend = Polyphony::Backend.new
     sleep 0.001

data/test/test_fiber.rb

@@ -791,7 +791,7 @@ class FiberTest < MiniTest::Test
     ], buf
   end
 
-  def test_attach
+  def test_attach_to
     buf = []
     child = nil
     parent = spin(:parent) do
@@ -809,7 +809,7 @@ class FiberTest < MiniTest::Test
 
     snooze
     assert_equal parent, child.parent
-    child.attach(new_parent)
+    child.attach_to(new_parent)
     assert_equal new_parent, child.parent
     parent.await
     

data/test/test_supervise.rb

@@ -2,29 +2,29 @@
 
 require_relative 'helper'
 
-# class SuperviseTest < MiniTest::Test
-#   def test_supervise
-#     p = spin { supervise }
-#     snooze
-#     f1 = p.spin { receive }
-#     f2 = p.spin { receive }
-
-#     snooze
-#     assert_equal p.state, :waiting
-#     f1 << 'foo'
-#     f1.await
-#     snooze
-
-#     assert_equal :waiting, p.state
-#     assert_equal :waiting, f2.state
-
-#     f2 << 'bar'
-#     f2.await
-#     assert_equal :runnable, p.state
-    
-#     3.times { snooze }
-#     assert_equal :dead, p.state
-#   end
+class SuperviseTest < MiniTest::Test
+  def test_supervise_with_no_arguments
+    assert_raises(RuntimeError) do
+      supervise
+    end
+  end
+  
+  def test_supervise_with_block
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) { supervise(f1, f2) { |*args| buffer << args } }
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [[f1, 'foo']], buffer
+
+    f2 << 'bar'
+    f2.await
+    assert_equal [[f1, 'foo'], [f2, 'bar']], buffer
+  end
 
 #   def test_supervise_with_restart
 #     watcher = spin { receive }
@@ -101,4 +101,4 @@ require_relative 'helper'
 #     assert :dead, f.state
 #     assert :dead, p.state
 #   end
-# end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.67'
+  version: '0.68'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-06 00:00:00.000000000 Z
+date: 2021-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -357,7 +357,7 @@ files:
 - lib/polyphony/core/thread_pool.rb
 - lib/polyphony/core/throttler.rb
 - lib/polyphony/core/timer.rb
-- lib/polyphony/debugger/server.rb
+- lib/polyphony/debugger.rb
 - lib/polyphony/extensions/core.rb
 - lib/polyphony/extensions/debug.rb
 - lib/polyphony/extensions/fiber.rb
@@ -421,7 +421,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Fine grained concurrency for Ruby

data/lib/polyphony/debugger/server.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require 'polyphony/extensions/debug'
-
-module Polyphony
-  class DebugServer
-    TP_EVENTS = [
-      :line,
-      :call,
-      :return,
-      :b_call,
-      :b_return
-    ]
-    
-    
-    def self.start(socket_path)
-      server = self.new(socket_path)
-      server.start
-    
-      trace = TracePoint.new(*TP_EVENTS) { |tp| server.handle_tp(trace, tp) }
-      trace.enable
-
-      at_exit do
-        puts "program terminated"
-        trace.disable
-        server.stop
-      end
-    end
-
-    def initialize(socket_path)
-      @socket_path = socket_path
-      @fiber = Fiber.current
-      @controller = spin { control_loop }
-      puts "@fiber: #{@fiber.inspect}"
-    end
-
-    def start
-      fiber = Fiber.current
-      @server = spin(:pdbg_server) do
-        puts("Listening on #{@socket_path}")
-        FileUtils.rm(@socket_path) if File.exists?(@socket_path)
-        socket = UNIXServer.new(@socket_path)
-        fiber << :ready
-        id = 0
-        socket.accept_loop do |client|
-          puts "accepted connection"
-          handle_client(client)
-        end
-      end
-      receive
-    end
-
-    def stop
-      @server.terminate
-      @controller.terminate
-    end
-
-    POLYPHONY_LIB_DIR = File.expand_path('../..', __dir__)
-    def handle_client(client)
-      @client = client
-      puts "trace enabled"
-    end
-
-    def control_loop
-      @cmd = :step
-      loop do
-        case @cmd
-        when :step
-          step
-        end
-      end
-    end
-
-    def step
-      tp = nil
-      fiber = nil
-      while true
-        event = receive
-        fiber = event[:fiber]
-        if fiber == @fiber && event[:kind] == :line && event[:path] !~ /#{POLYPHONY_LIB_DIR}/
-          interact_with_client(event)
-          fiber << :ok
-          fiber.__unpark__
-          return
-        end
-          
-        fiber << :ok
-        fiber.__unpark__
-      end
-    rescue => e
-      puts "Uncaught error: #{e.inspect}"
-      @trace&.disable
-      @client = nil
-    end
-
-    def interact_with_client(event)
-      @client.puts event.inspect
-      result = @client.gets&.chomp
-    end
-
-    def handle_tp(trace, tp)
-      return if @in_handle_tp
-
-      process_tp(trace, tp)
-    end
-
-    def process_tp(trace, tp)
-      @in_handle_tp = true
-      if !@client
-        wait_for_client
-      end
-
-      puts "- #{tp.event} #{tp.path}:#{tp.lineno}"
-
-      fiber = Fiber.current
-      fiber.__park__
-
-      @controller << {
-        fiber: fiber,
-        kind: tp.event,
-        path: tp.path,
-        lineno: tp.lineno
-      }
-      receive
-    ensure
-      @in_handle_tp = nil
-    end
-
-    def wait_for_client
-      puts "wait_for_client"
-      sleep 0.1 until @client
-      puts "  got client!"
-      msg = @client.gets
-      @client.puts msg
-    end
-  end
-end