133 lines
4.9 KiB
Ruby
133 lines
4.9 KiB
Ruby
require 'thread'
|
|
|
|
class Pry
|
|
# There is one InputLock per input (such as STDIN) as two REPLs on the same
|
|
# input makes things delirious. InputLock serializes accesses to the input so
|
|
# that threads to not conflict with each other. The latest thread to request
|
|
# ownership of the input wins.
|
|
class InputLock
|
|
class Interrupt < Exception; end
|
|
|
|
class << self
|
|
attr_accessor :input_locks
|
|
attr_accessor :global_lock
|
|
end
|
|
|
|
self.input_locks = {}
|
|
self.global_lock = Mutex.new
|
|
|
|
def self.for(input)
|
|
# XXX This method leaks memory, as we never unregister an input once we
|
|
# are done with it. Fortunately, the leak is tiny (or so we hope). In
|
|
# usual scenarios, we would leak the StringIO that is passed to be
|
|
# evaluated from the command line.
|
|
global_lock.synchronize do
|
|
input_locks[input] ||= Pry::InputLock.new
|
|
end
|
|
end
|
|
|
|
def initialize
|
|
@mutex = Mutex.new
|
|
@cond = ConditionVariable.new
|
|
@owners = []
|
|
@interruptible = false
|
|
end
|
|
|
|
# Adds ourselves to the ownership list. The last one in the list may access
|
|
# the input through interruptible_region().
|
|
def __with_ownership(&block)
|
|
@mutex.synchronize do
|
|
# Three cases:
|
|
# 1) There are no owners, in this case we are good to go.
|
|
# 2) The current owner of the input is not reading the input (it might
|
|
# just be evaluating some ruby that the user typed).
|
|
# The current owner will figure out that it cannot go back to reading
|
|
# the input since we are adding ourselves to the @owners list, which
|
|
# in turns makes us the current owner.
|
|
# 3) The owner of the input is in the interruptible region, reading from
|
|
# the input. It's safe to send an Interrupt exception to interrupt
|
|
# the owner. It will then proceed like in case 2).
|
|
# We wait until the owner sets the interruptible flag back
|
|
# to false, meaning that he's out of the interruptible region.
|
|
# Note that the owner may receive multiple interrupts since, but that
|
|
# should be okay (and trying to avoid it is futile anyway).
|
|
while @interruptible
|
|
@owners.last.raise Interrupt
|
|
@cond.wait(@mutex)
|
|
end
|
|
@owners << Thread.current
|
|
end
|
|
|
|
block.call
|
|
|
|
ensure
|
|
@mutex.synchronize do
|
|
# We are releasing any desire to have the input ownership by removing
|
|
# ourselves from the list.
|
|
@owners.delete(Thread.current)
|
|
|
|
# We need to wake up the thread at the end of the @owners list, but
|
|
# sadly Ruby doesn't allow us to choose which one we wake up, so we wake
|
|
# them all up.
|
|
@cond.broadcast
|
|
end
|
|
end
|
|
|
|
def with_ownership(&block)
|
|
# If we are in a nested with_ownership() call (nested pry context), we do nothing.
|
|
nested = @mutex.synchronize { @owners.include?(Thread.current) }
|
|
nested ? block.call : __with_ownership(&block)
|
|
end
|
|
|
|
def enter_interruptible_region
|
|
@mutex.synchronize do
|
|
# We patiently wait until we are the owner. This may happen as another
|
|
# thread calls with_ownership() because of a binding.pry happening in
|
|
# another thread.
|
|
@cond.wait(@mutex) until @owners.last == Thread.current
|
|
|
|
# We are the legitimate owner of the input. We mark ourselves as
|
|
# interruptible, so other threads can send us an Interrupt exception
|
|
# while we are blocking from reading the input.
|
|
@interruptible = true
|
|
end
|
|
end
|
|
|
|
def leave_interruptible_region
|
|
@mutex.synchronize do
|
|
# We check if we are still the owner, because we could have received an
|
|
# Interrupt right after the following @cond.broadcast, making us retry.
|
|
@interruptible = false if @owners.last == Thread.current
|
|
@cond.broadcast
|
|
end
|
|
rescue Interrupt
|
|
# We need to guard against a spurious interrupt delivered while we are
|
|
# trying to acquire the lock (the rescue block is no longer in our scope).
|
|
retry
|
|
end
|
|
|
|
def interruptible_region(&block)
|
|
enter_interruptible_region
|
|
|
|
# XXX Note that there is a chance that we get the interrupt right after
|
|
# the readline call succeeded, but we'll never know, and we will retry the
|
|
# call, discarding that piece of input.
|
|
block.call
|
|
|
|
rescue Interrupt
|
|
# We were asked to back off. The one requesting the interrupt will be
|
|
# waiting on the conditional for the interruptible flag to change to false.
|
|
# Note that there can be some inefficiency, as we could immediately
|
|
# succeed in enter_interruptible_region(), even before the one requesting
|
|
# the ownership has the chance to register itself as an owner.
|
|
# To mitigate the issue, we sleep a little bit.
|
|
leave_interruptible_region
|
|
sleep 0.01
|
|
retry
|
|
|
|
ensure
|
|
leave_interruptible_region
|
|
end
|
|
end
|
|
end
|