Class List Method List File List

# Class: Vertx::Context

Inherits:
  Object
  - Object
  - Vertx::Context
  show all
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/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.

## Class Method Summary (collapse)

- + (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.
- + (true, false) on_vertx_thread?
  Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread.
- + (true, false) on_worker_thread?
  Is the current thread a worker thread? NOTE! This is not always the same as calling #is_worker_context.

## Instance Method Summary (collapse)

- - (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.
- - (String) deployment_id
  If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
- - (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.
- - (Object) get(key = nil)
  Get some data from the context.
- - (Fixnum) get_instance_count
  @return the number of instances of the verticle that were deployed in the deployment (if any) related to this context.
- - (true, false) multi_threaded_worker_context?
  Is the current context a multi-threaded worker context?.
- - (::Vertx::Vertx) owner
  @return The Vertx instance that created the context.
- - (Array<String>) process_args
  The process args.
- - (void) put(key = nil, value = nil)
  Put some data in the context.
- - (true, false) remove?(key = nil)
  Remove some data from the context.
- - (void) run_on_context { ... }
  Run the specified action asynchronously on the same context, some time after the current execution has completed.
- - (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.

## Class Method Details

### + (`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`)

    61
    62
    63
    64
    65
    66
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 61

    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`)

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

    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`)

    50
    51
    52
    53
    54
    55
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 50

    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

## 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`)

    95
    96
    97
    98
    99
    100
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 95

    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`)

    86
    87
    88
    89
    90
    91
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 86

    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`)

    115
    116
    117
    118
    119
    120
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 115

    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

### - (`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`)

    144
    145
    146
    147
    148
    149
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 144

    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

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

Returns:

- (`Fixnum`)

Raises:

- (`ArgumentError`)

    182
    183
    184
    185
    186
    187
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 182

    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

### - (`true`, `false`) multi_threaded_worker_context?

Is the current context a multi-threaded worker context?

Returns:

- (`true`, `false`) —
  true if the current context is a multi-threaded worker context, false otherwise

Raises:

- (`ArgumentError`)

    135
    136
    137
    138
    139
    140
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 135

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

### - (`::Vertx::Vertx`) owner

@return The Vertx instance that created the context

Returns:

- (`::Vertx::Vertx`)

Raises:

- (`ArgumentError`)

    173
    174
    175
    176
    177
    178
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 173

    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`)

    103
    104
    105
    106
    107
    108
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 103

    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`)

    156
    157
    158
    159
    160
    161
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 156

    def put(key=nil,value=nil)
      if key.class == String && (value.class == String  || value.class == Hash || value.class == Array || value.class == NilClass || value.class == TrueClass || value.class == FalseClass || value.class == Fixnum || value.class == Float) && !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

### - (`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`)

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

    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

### - (`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`)

    78
    79
    80
    81
    82
    83
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 78

    def run_on_context
      if block_given?
        return @j_del.java_method(:runOnContext, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
      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`)

    127
    128
    129
    130
    131
    132
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/context.rb', line 127

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