Class: Vertx::Context

Inherits:
Object
  • Object
show all
Defined in:
/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb

Overview

The execution context of a Proc execution.

When Vert.x provides an event to a handler or calls the start or stop methods of a Nil, the execution is associated with a Context.

Usually a context is an *event-loop context* and is tied to a specific event loop thread. So executions for that context always occur on that exact same event loop thread.

In the case of worker verticles and running inline blocking code a worker context will be associated with the execution which will use a thread from the worker thread pool.

When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler is executed, that execution will be associated with the same context.

If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will be created for that handler.

In other words, a context is propagated.

This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context of the verticle.

This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application as single threaded.

This class also allows arbitrary data to be #put and #get on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

This class also provides #run_on_context which allows an action to be executed asynchronously using the same context.

Constant Summary

@@j_api_type =
Object.new

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Boolean) accept?(obj)

Returns:

  • (Boolean)


49
50
51
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 49

def @@j_api_type.accept?(obj)
  obj.class == Context
end

+ (Object) j_api_type



58
59
60
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 58

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class



61
62
63
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 61

def self.j_class
  Java::IoVertxCore::Context.java_class
end

+ (true, false) on_event_loop_thread?

Is the current thread an event thread?

NOTE! This is not always the same as calling #is_event_loop_context. If you are running blocking code from an event loop context, then this will return false but #is_event_loop_context will return true.

Returns:

  • (true, false)
    true if current thread is a worker thread, false otherwise

Raises:

  • (ArgumentError)


80
81
82
83
84
85
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 80

def self.on_event_loop_thread?
  if !block_given?
    return Java::IoVertxCore::Context.java_method(:isOnEventLoopThread, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling on_event_loop_thread?()"
end

+ (true, false) on_vertx_thread?

Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread

Returns:

  • (true, false)
    true if current thread is a Vert.x thread, false otherwise

Raises:

  • (ArgumentError)


88
89
90
91
92
93
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 88

def self.on_vertx_thread?
  if !block_given?
    return Java::IoVertxCore::Context.java_method(:isOnVertxThread, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling on_vertx_thread?()"
end

+ (true, false) on_worker_thread?

Is the current thread a worker thread?

NOTE! This is not always the same as calling #is_worker_context. If you are running blocking code from an event loop context, then this will return true but #is_worker_context will return false.

Returns:

  • (true, false)
    true if current thread is a worker thread, false otherwise

Raises:

  • (ArgumentError)


69
70
71
72
73
74
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 69

def self.on_worker_thread?
  if !block_given?
    return Java::IoVertxCore::Context.java_method(:isOnWorkerThread, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling on_worker_thread?()"
end

+ (Object) unwrap(obj)



55
56
57
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 55

def @@j_api_type.unwrap(obj)
  obj.j_del
end

+ (Object) wrap(obj)



52
53
54
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 52

def @@j_api_type.wrap(obj)
  Context.new(obj)
end

Instance Method Details

- (Hash{String => Object}) config

If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.

Returns:

  • (Hash{String => Object})
    the configuration of the deployment or null if not a Verticle deployment

Raises:

  • (ArgumentError)


145
146
147
148
149
150
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 145

def config
  if !block_given?
    return @j_del.java_method(:config, []).call() != nil ? JSON.parse(@j_del.java_method(:config, []).call().encode) : nil
  end
  raise ArgumentError, "Invalid arguments when calling config()"
end

- (String) deployment_id

If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.

Returns:

  • (String)
    the deployment ID of the deployment or null if not a Verticle deployment

Raises:

  • (ArgumentError)


136
137
138
139
140
141
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 136

def deployment_id
  if !block_given?
    return @j_del.java_method(:deploymentID, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling deployment_id()"
end

- (true, false) event_loop_context?

Is the current context an event loop context?

NOTE! when running blocking code using Vertx#execute_blocking from a standard (not worker) verticle, the context will still an event loop context and this will return true.

Returns:

  • (true, false)
    true if false otherwise

Raises:

  • (ArgumentError)


165
166
167
168
169
170
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 165

def event_loop_context?
  if !block_given?
    return @j_del.java_method(:isEventLoopContext, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling event_loop_context?()"
end

- (self) exception_handler { ... }

Set an exception handler called when the context runs an action throwing an uncaught throwable.

When this handler is called, Vertx#current_context will return this context.

Yields:

  • the exception handler

Returns:

  • (self)

Raises:

  • (ArgumentError)


262
263
264
265
266
267
268
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 262

def exception_handler
  if true
    @j_del.java_method(:exceptionHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.from_throwable(event)) unless !block_given? }))
    return self
  end
  raise ArgumentError, "Invalid arguments when calling exception_handler()"
end

- (void) execute_blocking(blockingCodeHandler = nil, ordered = nil) { ... }

This method returns an undefined value.

Safely execute some blocking code.

Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.

When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).

A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise#complete or Promise#complete method, or the Promise#fail method if it failed.

The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or #run_on_context

Parameters:

  • blockingCodeHandler (Proc) (defaults to: nil)
    handler representing the blocking code to run
  • ordered (true, false) (defaults to: nil)
    if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees

Yields:

  • handler that will be called when the blocking code is complete

Raises:

  • (ArgumentError)


126
127
128
129
130
131
132
133
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 126

def execute_blocking(blockingCodeHandler=nil,ordered=nil)
  if blockingCodeHandler.class == Proc && true && ordered == nil
    return @j_del.java_method(:executeBlocking, [Java::IoVertxCore::Handler.java_class,Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| blockingCodeHandler.call(::Vertx::Util::Utils.safe_create(event,::Vertx::Promise, nil)) unless blockingCodeHandler == nil }),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.from_object(ar.result) : nil) } unless !block_given?))
  elsif blockingCodeHandler.class == Proc && (ordered.class == TrueClass || ordered.class == FalseClass) && true
    return @j_del.java_method(:executeBlocking, [Java::IoVertxCore::Handler.java_class,Java::boolean.java_class,Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| blockingCodeHandler.call(::Vertx::Util::Utils.safe_create(event,::Vertx::Promise, nil)) unless blockingCodeHandler == nil }),ordered,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.from_object(ar.result) : nil) } unless !block_given?))
  end
  raise ArgumentError, "Invalid arguments when calling execute_blocking(#{blockingCodeHandler},#{ordered})"
end

- (Object) get(key = nil)

Get some data from the context.

Parameters:

  • key (String) (defaults to: nil)
    the key of the data

Returns:

  • (Object)
    the data

Raises:

  • (ArgumentError)


186
187
188
189
190
191
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 186

def get(key=nil)
  if key.class == String && !block_given?
    return ::Vertx::Util::Utils.from_object(@j_del.java_method(:get, [Java::java.lang.String.java_class]).call(key))
  end
  raise ArgumentError, "Invalid arguments when calling get(#{key})"
end

- (Fixnum) get_instance_count

Returns the number of instances of the verticle that were deployed in the deployment (if any) related to this context

Returns:

  • (Fixnum)
    the number of instances of the verticle that were deployed in the deployment (if any) related to this context

Raises:

  • (ArgumentError)


251
252
253
254
255
256
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 251

def get_instance_count
  if !block_given?
    return @j_del.java_method(:getInstanceCount, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling get_instance_count()"
end

- (Object) get_local(key = nil)

Get some local data from the context.

Parameters:

  • key (String) (defaults to: nil)
    the key of the data

Returns:

  • (Object)
    the data

Raises:

  • (ArgumentError)


216
217
218
219
220
221
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 216

def get_local(key=nil)
  if key.class == String && !block_given?
    return ::Vertx::Util::Utils.from_object(@j_del.java_method(:getLocal, [Java::java.lang.String.java_class]).call(key))
  end
  raise ArgumentError, "Invalid arguments when calling get_local(#{key})"
end

- (::Vertx::Vertx) owner

Returns The Vertx instance that created the context

Returns:

Raises:

  • (ArgumentError)


244
245
246
247
248
249
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 244

def owner
  if !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:owner, []).call(),::Vertx::Vertx)
  end
  raise ArgumentError, "Invalid arguments when calling owner()"
end

- (Array<String>) process_args

The process args

Returns:

  • (Array<String>)

Raises:

  • (ArgumentError)


153
154
155
156
157
158
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 153

def process_args
  if !block_given?
    return @j_del.java_method(:processArgs, []).call().to_a.map { |elt| elt }
  end
  raise ArgumentError, "Invalid arguments when calling process_args()"
end

- (void) put(key = nil, value = nil)

This method returns an undefined value.

Put some data in the context.

This can be used to share data between different handlers that share a context

Parameters:

  • key (String) (defaults to: nil)
    the key of the data
  • value (Object) (defaults to: nil)
    the data

Raises:

  • (ArgumentError)


198
199
200
201
202
203
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 198

def put(key=nil,value=nil)
  if key.class == String && ::Vertx::Util::unknown_type.accept?(value) && !block_given?
    return @j_del.java_method(:put, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class]).call(key,::Vertx::Util::Utils.to_object(value))
  end
  raise ArgumentError, "Invalid arguments when calling put(#{key},#{value})"
end

- (void) put_local(key = nil, value = nil)

This method returns an undefined value.

Put some local data in the context.

This can be used to share data between different handlers that share a context

Parameters:

  • key (String) (defaults to: nil)
    the key of the data
  • value (Object) (defaults to: nil)
    the data

Raises:

  • (ArgumentError)


228
229
230
231
232
233
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 228

def put_local(key=nil,value=nil)
  if key.class == String && ::Vertx::Util::unknown_type.accept?(value) && !block_given?
    return @j_del.java_method(:putLocal, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class]).call(key,::Vertx::Util::Utils.to_object(value))
  end
  raise ArgumentError, "Invalid arguments when calling put_local(#{key},#{value})"
end

- (true, false) remove?(key = nil)

Remove some data from the context.

Parameters:

  • key (String) (defaults to: nil)
    the key to remove

Returns:

  • (true, false)
    true if removed successfully, false otherwise

Raises:

  • (ArgumentError)


207
208
209
210
211
212
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 207

def remove?(key=nil)
  if key.class == String && !block_given?
    return @j_del.java_method(:remove, [Java::java.lang.String.java_class]).call(key)
  end
  raise ArgumentError, "Invalid arguments when calling remove?(#{key})"
end

- (true, false) remove_local?(key = nil)

Remove some local data from the context.

Parameters:

  • key (String) (defaults to: nil)
    the key to remove

Returns:

  • (true, false)
    true if removed successfully, false otherwise

Raises:

  • (ArgumentError)


237
238
239
240
241
242
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 237

def remove_local?(key=nil)
  if key.class == String && !block_given?
    return @j_del.java_method(:removeLocal, [Java::java.lang.String.java_class]).call(key)
  end
  raise ArgumentError, "Invalid arguments when calling remove_local?(#{key})"
end

- (void) run_on_context { ... }

This method returns an undefined value.

Run the specified action asynchronously on the same context, some time after the current execution has completed.

Yields:

  • the action to run

Raises:

  • (ArgumentError)


97
98
99
100
101
102
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 97

def run_on_context
  if true
    return @j_del.java_method(:runOnContext, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield unless !block_given? })
  end
  raise ArgumentError, "Invalid arguments when calling run_on_context()"
end

- (true, false) worker_context?

Is the current context a worker context?

NOTE! when running blocking code using Vertx#execute_blocking from a standard (not worker) verticle, the context will still an event loop context and this will return false.

Returns:

  • (true, false)
    true if the current context is a worker context, false otherwise

Raises:

  • (ArgumentError)


177
178
179
180
181
182
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/context.rb', line 177

def worker_context?
  if !block_given?
    return @j_del.java_method(:isWorkerContext, []).call()
  end
  raise ArgumentError, "Invalid arguments when calling worker_context?()"
end