Module: Mongo::BackgroundThread Private

# File 'lib/mongo/background_thread.rb', line 170

def pre_stop
end

# File 'lib/mongo/background_thread.rb', line 46

def run!
  if @stop_requested && @thread
    wait_for_stop
    if @thread.alive?
      log_warn("Starting a new background thread in #{self}, but the previous background thread is still running")
      @thread = nil
    end
    @stop_requested = false
  end
  if running?
    @thread
  else
    start!
  end
end

# File 'lib/mongo/background_thread.rb', line 111

def start!
  @thread = Thread.new do
    catch(:done) do
      until @stop_requested
        do_work
      end
    end
  end
end

# File 'lib/mongo/background_thread.rb', line 77

def stop!
  # If the thread was not started, there is nothing to stop.
  #
  # Classes including this module may want to perform additional
  # cleanup, which they can do by overriding this method.
  return true unless @thread

  # Background threads generally perform operations in a loop.
  # This flag is meant to be checked on each iteration of the
  # working loops and the thread should stop working when this flag
  # is set.
  @stop_requested = true

  # Besides setting the flag, a particular class may have additional
  # ways of signaling the background thread to either stop working or
  # wake up to check the stop flag, for example, setting a semaphore.
  # This can be accomplished by providing the pre_stop method.
  pre_stop

  # Now we have requested the graceful termination, and we could wait
  # for the thread to exit on its own accord. A future version of the
  # driver may allow a certain amount of time for the thread to quit.
  # For now, we additionally use the Ruby machinery to request the thread
  # be terminated, and do so immediately.
  #
  # Note that this may cause the background thread to terminate in
  # the middle of an operation.
  @thread.kill

  wait_for_stop
end

# File 'lib/mongo/background_thread.rb', line 124

def wait_for_stop
  # Wait for the thread to die. This is important in order to reliably
  # clean up resources like connections knowing that no background
  # thread will reconnect because it is still working.
  #
  # However, we do not want to wait indefinitely because in theory
  # a background thread could be performing, say, network I/O and if
  # the network is no longer available that could take a long time.
  start_time = Utils.monotonic_time
  ([0.1, 0.15] + [0.2] * 5 + [0.3] * 20).each do |interval|
    begin
      Timeout.timeout(interval) do
        @thread.join
      end
      break
    rescue ::Timeout::Error
    end
  end

  # Some driver objects can be reconnected, for backwards compatibiilty
  # reasons. Clear the thread instance variable to support this cleanly.
  if @thread.alive?
    log_warn("Failed to stop the background thread in #{self} in #{(Utils.monotonic_time - start_time).to_i} seconds: #{@thread.inspect} (thread status: #{@thread.status})")
    # On JRuby the thread may be stuck in aborting state
    # seemingly indefinitely. If the thread is aborting, consider it dead
    # for our purposes (we will create a new thread if needed, and
    # the background thread monitor will not detect the aborting thread
    # as being alive).
    if @thread.status == 'aborting'
      @thread = nil
      @stop_requested = false
    end
    false
  else
    @thread = nil
    @stop_requested = false
    true
  end
end