Class: Celluloid::Cell

Inherits:
Object
  • Object
show all
Defined in:
lib/celluloid/cell.rb

Overview

Wrap the given subject with an Cell

Defined Under Namespace

Classes: ExitHandler

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(subject, options, actor_options) ⇒ Cell

Returns a new instance of Cell.


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# File 'lib/celluloid/cell.rb', line 20

def initialize(subject, options, actor_options)
  @actor                      = Actor.new(self, actor_options)
  @subject                    = subject
  @receiver_block_executions  = options[:receiver_block_executions]
  @exclusive_methods          = options[:exclusive_methods]
  @finalizer                  = options[:finalizer]

  @subject.instance_variable_set(OWNER_IVAR, @actor)

  if exit_handler_name = options[:exit_handler_name]
    @actor.exit_handler = ExitHandler.new(self, @subject, exit_handler_name)
  end

  @actor.handle(Call) do |message|
    invoke(message)
  end
  @actor.handle(Call::Block) do |message|
    task(:invoke_block) { message.dispatch }
  end
  @actor.handle(Internals::Response::Block, Internals::Response, &:dispatch)

  @actor.start
  @proxy = (options[:proxy_class] || Proxy::Cell).new(@actor.mailbox, @actor.proxy, @subject.class.to_s)
end

Instance Attribute Details

#proxyObject (readonly)

Returns the value of attribute proxy


44
45
46
# File 'lib/celluloid/cell.rb', line 44

def proxy
  @proxy
end

#subjectObject (readonly)

Returns the value of attribute subject


44
45
46
# File 'lib/celluloid/cell.rb', line 44

def subject
  @subject
end

Class Method Details

.dispatchObject


46
47
48
49
50
51
52
# File 'lib/celluloid/cell.rb', line 46

def self.dispatch
  proc do |subject|
    subject[:call].dispatch(subject[:subject])
    subject[:call] = nil
    subject[:subject] = nil
  end
end

.shutdownObject


77
78
79
80
81
82
83
84
85
86
87
# File 'lib/celluloid/cell.rb', line 77

def self.shutdown
  proc do |subject|
    begin
      subject[:subject].__send__(subject[:call])
    rescue => ex
      Internals::Logger.crash("#{subject[:subject].class} finalizer crashed!", ex)
    end
    subject[:call] = nil
    subject[:subject] = nil
  end
end

Instance Method Details

#invoke(call) ⇒ Object


54
55
56
57
58
59
60
61
62
63
# File 'lib/celluloid/cell.rb', line 54

def invoke(call)
  meth = call.method
  meth = call.arguments.first if meth == :__send__
  if @receiver_block_executions && meth
    call.execute_block_on_receiver if @receiver_block_executions.include?(meth.to_sym)
  end

  task(:call, meth, { call: call, subject: @subject },
       dangerous_suspend: meth == :initialize, &Cell.dispatch)
end

#shutdownObject

Run the user-defined finalizer, if one is set


90
91
92
93
94
95
# File 'lib/celluloid/cell.rb', line 90

def shutdown
  return unless @finalizer && @subject.respond_to?(@finalizer, true)

  task(:finalizer, @finalizer, { call: @finalizer, subject: @subject },
       dangerous_suspend: true, &Cell.shutdown)
end

#task(task_type, method_name = nil, subject = nil, meta = nil, &_block) ⇒ Object


65
66
67
68
69
70
71
72
73
74
75
# File 'lib/celluloid/cell.rb', line 65

def task(task_type, method_name = nil, subject = nil, meta = nil, &_block)
  meta ||= {}
  meta[:method_name] = method_name
  @actor.task(task_type, meta) do
    if @exclusive_methods && method_name && @exclusive_methods.include?(method_name.to_sym)
      Celluloid.exclusive { yield subject }
    else
      yield subject
    end
  end
end