Class: Concurrent::Actor::AbstractContext Abstract

Inherits:
Object
  • Object
show all
Includes:
Concern::Logging, InternalDelegations, TypeCheck
Defined in:
lib/concurrent/actor/context.rb

Overview

This class is abstract.

implement #on_message and #behaviour_definition

New actor is defined by subclassing RestartingContext, Context and defining its abstract methods. AbstractContext can be subclassed directly to implement more specific behaviour see Root implementation.

Example of ac actor definition:

See methods of AbstractContext what else can be tweaked, e.g #default_reference_class

Direct Known Subclasses

Context, RestartingContext, Root

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from InternalDelegations

#behaviour, #behaviour!, #children, #context, #log, #redirect, #terminate!, #terminated?

Methods included from PublicDelegations

#context_class, #executor, #name, #parent, #path, #reference

Methods included from TypeCheck

#Child!, #Child?, #Match!, #Match?, #Type!, #Type?

Instance Attribute Details

#core ⇒ Object (readonly) 



29
30
31
 
# File 'lib/concurrent/actor/context.rb', line 29

def core
  @core
end

Class Method Details

.spawn(name_or_opts, *args, &block) ⇒ Object

Behaves as Concurrent::Actor.spawn but :class is auto-inserted based on receiver so it can be omitted.

Examples:

by class and name

AdHoc.spawn(:ping1) { -> message { message } }

by option hash

inc2 = AdHoc.spawn(name:     'increment by 2',
                   args:     [2],
                   executor: Concurrent.configuration.global_task_pool) do |increment_by|
  lambda { |number| number + increment_by }
end
inc2.ask!(2) # => 4

See Also:



116
117
118
 
# File 'lib/concurrent/actor/context.rb', line 116

def self.spawn(name_or_opts, *args, &block)
  Actor.spawn to_spawn_options(name_or_opts, *args), &block
end

.spawn!(name_or_opts, *args, &block) ⇒ Object

behaves as Concurrent::Actor.spawn! but :class is auto-inserted based on receiver so it can be omitted.



121
122
123
 
# File 'lib/concurrent/actor/context.rb', line 121

def self.spawn!(name_or_opts, *args, &block)
  Actor.spawn! to_spawn_options(name_or_opts, *args), &block
end

Instance Method Details

#ask(message) ⇒ Object Also known as: ask! 



97
98
99
 
# File 'lib/concurrent/actor/context.rb', line 97

def ask(message)
  raise 'actor cannot ask itself'
end

#behaviour_definition ⇒ Array<Array(Behavior::Abstract, Array<Object>)>

Returns:

  • (Array<Array(Behavior::Abstract, Array<Object>)>)

Raises:

  • (NotImplementedError) 


71
72
73
 
# File 'lib/concurrent/actor/context.rb', line 71

def behaviour_definition
  raise NotImplementedError
end

#dead_letter_routing ⇒ Reference

Defines an actor responsible for dead letters. Any rejected message send with Reference#tell is sent there, a message with future is considered already monitored for failures. Default behaviour is to use #dead_letter_routing of the parent, so if no #dead_letter_routing method is overridden in parent-chain the message ends up in ‘Actor.root.dead_letter_routing` agent which will log warning.

Returns:



66
67
68
 
# File 'lib/concurrent/actor/context.rb', line 66

def dead_letter_routing
  parent.dead_letter_routing
end

#default_executor ⇒ Executor

override to se different default executor, e.g. to change it to global_operation_pool

Returns:

  • (Executor) 


88
89
90
 
# File 'lib/concurrent/actor/context.rb', line 88

def default_executor
  Concurrent.global_io_executor
end

#default_reference_class ⇒ CLass

override if different class for reference is needed

Returns:



82
83
84
 
# File 'lib/concurrent/actor/context.rb', line 82

def default_reference_class
  Reference
end

#envelope ⇒ Envelope

Returns current envelope, accessible inside #on_message processing.

Returns:

  • (Envelope) —

    current envelope, accessible inside #on_message processing



76
77
78
 
# File 'lib/concurrent/actor/context.rb', line 76

def envelope
  @envelope or raise 'envelope not set'
end

#on_envelope(envelope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



45
46
47
48
49
50
 
# File 'lib/concurrent/actor/context.rb', line 45

def on_envelope(envelope)
  @envelope = envelope
  on_message envelope.message
ensure
  @envelope = nil
end

#on_event(event) ⇒ Object

override to add custom code invocation on internal events like ‘:terminated`, `:resumed`, `anError`.



41
42
 
# File 'lib/concurrent/actor/context.rb', line 41

def on_event(event)
end

#on_message(message) ⇒ Object

This method is abstract.

override to define Actor’s behaviour

Note:

self should not be returned (or sent to other actors), PublicDelegations#reference should be used instead

Returns a result which will be used to set the Future supplied to Reference#ask.

Parameters:

  • message (Object)

Returns:

  • (Object) —

    a result which will be used to set the Future supplied to Reference#ask

Raises:

  • (NotImplementedError) 


36
37
38
 
# File 'lib/concurrent/actor/context.rb', line 36

def on_message(message)
  raise NotImplementedError
end

#pass ⇒ Object

if you want to pass the message to next behaviour, usually Behaviour::ErrorsOnUnknownMessage



54
55
56
 
# File 'lib/concurrent/actor/context.rb', line 54

def pass
  core.behaviour!(Behaviour::ExecutesContext).pass envelope
end

#tell(message) ⇒ Object Also known as: <<

tell self a message



93
94
95
 
# File 'lib/concurrent/actor/context.rb', line 93

def tell(message)
  reference.tell message
end