Celluloid

# File lib/celluloid.rb, line 49
def actor?
  !!Thread.current[:celluloid_actor]
end

# File lib/celluloid.rb, line 103
def boot
  init
  start
end

# File lib/celluloid.rb, line 64
def cores
 CPUCounter.cores
end

# File lib/celluloid.rb, line 77
def detect_recursion
  actor = Thread.current[:celluloid_actor]
  return unless actor

  task = Thread.current[:celluloid_task]
  return unless task

  chain_id = CallChain.current_id
  actor.tasks.to_a.any? { |t| t != task && t.chain_id == chain_id }
end

# File lib/celluloid.rb, line 89
def exception_handler(&block)
  Logger.exception_handler(&block)
end

# File lib/celluloid.rb, line 25
def included(klass)
  klass.send :extend,  ClassMethods
  klass.send :include, InstanceMethods

  klass.send :extend, Properties

  klass.property :mailbox_class, :default => Celluloid::Mailbox
  klass.property :proxy_class,   :default => Celluloid::ActorProxy
  klass.property :task_class,    :default => Celluloid.task_class
  klass.property :mailbox_size

  klass.property :execute_block_on_receiver,
    :default => [:after, :every, :receive],
    :multi   => true

  klass.property :finalizer
  klass.property :exit_handler

  klass.send(:define_singleton_method, :trap_exit) do |*args|
    exit_handler(*args)
  end
end

# File lib/celluloid.rb, line 108
def init
  self.internal_pool = InternalPool.new
end

# File lib/celluloid.rb, line 54
def mailbox
  Thread.current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
end

# File lib/celluloid.rb, line 119
def register_shutdown
  return if @shutdown_registered
  # Terminate all actors at exit
  at_exit do
    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
      # workaround for MRI bug losing exit status in at_exit block
      # http://bugs.ruby-lang.org/issues/5218
      exit_status = $!.status if $!.is_a?(SystemExit)
      Celluloid.shutdown
      exit exit_status if exit_status
    else
      Celluloid.shutdown
    end
  end
  @shutdown_registered = true
end

# File lib/celluloid.rb, line 137
def shutdown
  actors = Actor.all

  Timeout.timeout(shutdown_timeout) do
    internal_pool.shutdown

    Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0

    # Attempt to shut down the supervision tree, if available
    Supervisor.root.terminate if Supervisor.root

    # Actors cannot self-terminate, you must do it for them
    actors.each do |actor|
      begin
        actor.terminate!
      rescue DeadActorError
      end
    end

    actors.each do |actor|
      begin
        Actor.join(actor)
      rescue DeadActorError
      end
    end
  end
rescue Timeout::Error
  Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
  actors.each do |actor|
    begin
      Actor.kill(actor)
    rescue DeadActorError, MailboxDead
    end
  end
ensure
  internal_pool.kill
end

# File lib/celluloid.rb, line 71
def stack_dump(output = STDERR)
  Celluloid::StackDump.new.dump(output)
end

# File lib/celluloid.rb, line 114
def start
  Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
  Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
end

# File lib/celluloid.rb, line 93
def suspend(status, waiter)
  task = Thread.current[:celluloid_task]
  if task && !Celluloid.exclusive?
    waiter.before_suspend(task) if waiter.respond_to?(:before_suspend)
    Task.suspend(status)
  else
    waiter.wait
  end
end

# File lib/celluloid.rb, line 59
def uuid
  UUID.generate
end

# File lib/celluloid.rb, line 175
def version
  VERSION
end

# File lib/celluloid.rb, line 323
def abort(cause)
  cause = case cause
    when String then RuntimeError.new(cause)
    when Exception then cause
    else raise TypeError, "Exception object/String expected, but #{cause.class} received"
  end
  raise AbortError.new(cause)
end

# File lib/celluloid.rb, line 437
def after(interval, &block)
  Thread.current[:celluloid_actor].after(interval, &block)
end

# File lib/celluloid.rb, line 456
def async(meth = nil, *args, &block)
  Thread.current[:celluloid_actor].proxy.async meth, *args, &block
end

# File lib/celluloid.rb, line 353
def call_chain_id
  CallChain.current_id
end

# File lib/celluloid.rb, line 348
def current_actor
  Actor.current
end

# File lib/celluloid.rb, line 449
def defer(&block)
  # This implementation relies on the present implementation of
  # Celluloid::Future, which uses a thread from InternalPool to run the block
  Future.new(&block).value
end

# File lib/celluloid.rb, line 442
def every(interval, &block)
  Thread.current[:celluloid_actor].every(interval, &block)
end

# File lib/celluloid.rb, line 426
def exclusive(&block)
  Thread.current[:celluloid_task].exclusive(&block)
end

# File lib/celluloid.rb, line 431
def exclusive?
  task = Thread.current[:celluloid_task]
  task && task.exclusive?
end

# File lib/celluloid.rb, line 461
def future(meth = nil, *args, &block)
  Thread.current[:celluloid_actor].proxy.future meth, *args, &block
end

# File lib/celluloid.rb, line 378
def link(actor)
  Actor.link(actor)
end

# File lib/celluloid.rb, line 393
def linked_to?(actor)
  Actor.linked_to?(actor)
end

# File lib/celluloid.rb, line 363
def links
  Thread.current[:celluloid_actor].links
end

# File lib/celluloid.rb, line 368
def monitor(actor)
  Actor.monitor(actor)
end

# File lib/celluloid.rb, line 388
def monitoring?(actor)
  Actor.monitoring?(actor)
end

# File lib/celluloid.rb, line 398
def receive(timeout = nil, &block)
  actor = Thread.current[:celluloid_actor]
  if actor
    actor.receive(timeout, &block)
  else
    Celluloid.mailbox.receive(timeout, &block)
  end
end

# File lib/celluloid.rb, line 338
def signal(name, value = nil)
  Thread.current[:celluloid_actor].signal name, value
end

# File lib/celluloid.rb, line 408
def sleep(interval)
  actor = Thread.current[:celluloid_actor]
  if actor
    actor.sleep(interval)
  else
    Kernel.sleep interval
  end
end

# File lib/celluloid.rb, line 358
def tasks
  Thread.current[:celluloid_actor].tasks.to_a
end

# File lib/celluloid.rb, line 333
def terminate
  Thread.current[:celluloid_actor].proxy.terminate!
end

# File lib/celluloid.rb, line 418
def timeout(duration)
  Thread.current[:celluloid_actor].timeout(duration) do
    yield
  end
end

# File lib/celluloid.rb, line 383
def unlink(actor)
  Actor.unlink(actor)
end

# File lib/celluloid.rb, line 373
def unmonitor(actor)
  Actor.unmonitor(actor)
end

# File lib/celluloid.rb, line 343
def wait(name)
  Thread.current[:celluloid_actor].wait name
end