Class: Vertx::Vertx

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

Overview

The entry point into the Vert.x Core API.

You use an instance of this class for functionality including:

  • Creating TCP clients and servers
  • Creating HTTP clients and servers
  • Creating DNS clients
  • Creating Datagram sockets
  • Setting and cancelling periodic and one-shot timers
  • Getting a reference to the event bus API
  • Getting a reference to the file system API
  • Getting a reference to the shared data API
  • Deploying and undeploying verticles

Most functionality in Vert.x core is fairly low level.

To create an instance of this class you can use the static factory methods: #vertx, #vertx and #clustered_vertx.

Please see the user manual for more detailed usage information.

Constant Summary

@@j_api_type =
Object.new

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Boolean) accept?(obj)

Returns:

  • (Boolean)


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

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

+ (void) clusteredVertx(options, resultHandler) { ... }

This method returns an undefined value.

Creates a clustered instance using the specified options.

The instance is created asynchronously and the resultHandler is called with the result when it is ready.

Parameters:

  • options (Hash{String => Object})
    the options to use

Yields:

  • the result handler that will receive the result


298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 298

def self.clustered_vertx(*args)
  if args[0].class == Hash && true
    if (block_given?)
      return Java::IoVertxCore::Vertx.java_method(:clusteredVertx, [Java::IoVertxCore::VertxOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCore::VertxOptions.new(::Vertx::Util::Utils.to_json_object(args[0])),block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Vertx) : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      Java::IoVertxCore::Vertx.java_method(:clusteredVertx, [Java::IoVertxCore::VertxOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxCore::VertxOptions.new(::Vertx::Util::Utils.to_json_object(args[0])),block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Vertx) : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future,::Vertx::Vertx.j_api_type)
    end
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling clustered_vertx(#{args[0]})"
  end
end

+ (::Vertx::Context) currentContext

Gets the current context

Returns:



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

def self.current_context
  if !block_given?
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCore::Vertx.java_method(:currentContext, []).call(),::Vertx::Context)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling current_context()"
  end
end

+ (Object) j_api_type



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

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class



66
67
68
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 66

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

+ (Object) unwrap(obj)



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

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

+ (::Vertx::Vertx) vertx + (::Vertx::Vertx) vertx(options)

Creates a non clustered instance using the specified options

Overloads:

  • + (::Vertx::Vertx) vertx(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



138
139
140
141
142
143
144
145
146
147
148
149
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 138

def self.vertx(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCore::Vertx.java_method(:vertx, []).call(),::Vertx::Vertx)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCore::Vertx.java_method(:vertx, [Java::IoVertxCore::VertxOptions.java_class]).call(Java::IoVertxCore::VertxOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::Vertx)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling vertx(#{args[0]})"
  end
end

+ (Object) wrap(obj)



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

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

Instance Method Details

- (true, false) cancelTimer(id)

Cancels the timer with the specified id.

Parameters:

  • id (Fixnum)
    The id of the timer to cancel

Returns:

  • (true, false)
    true if the timer was successfully cancelled, or false if the timer does not exist.


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

def cancel_timer?(*args)
  if args[0].class == Fixnum && !block_given?
    return @j_del.java_method(:cancelTimer, [Java::long.java_class]).call(args[0])
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling cancel_timer?(#{args[0]})"
  end
end

- (void) close(completionHandler) { ... }

This method returns an undefined value.

Like #close but the completionHandler will be called when the close is complete

Yields:

  • The handler will be notified when the close is complete.


218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 218

def close
  if true
    if (block_given?)
      return @j_del.java_method(:close, [Java::IoVertxCore::Handler.java_class]).call(block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      @j_del.java_method(:close, [Java::IoVertxCore::Handler.java_class]).call(block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future, nil)
    end
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling close()"
  end
end

- (true, false) isClustered

Is this Vert.x instance clustered?

Returns:

  • (true, false)
    true if clustered


435
436
437
438
439
440
441
442
443
444
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 435

def clustered?
  if !block_given?
    return @j_del.java_method(:isClustered, []).call()
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling clustered?()"
  end
end

- (::Vertx::DatagramSocket) createDatagramSocket - (::Vertx::DatagramSocket) createDatagramSocket(options)

Create a datagram socket using the specified options

Overloads:

  • - (::Vertx::DatagramSocket) createDatagramSocket(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



558
559
560
561
562
563
564
565
566
567
568
569
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 558

def create_datagram_socket(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDatagramSocket, []).call(),::Vertx::DatagramSocket)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDatagramSocket, [Java::IoVertxCoreDatagram::DatagramSocketOptions.java_class]).call(Java::IoVertxCoreDatagram::DatagramSocketOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::DatagramSocket)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_datagram_socket(#{args[0]})"
  end
end

- (::Vertx::DnsClient) createDnsClient - (::Vertx::DnsClient) createDnsClient(options) - (::Vertx::DnsClient) createDnsClient(port, host)

Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)

Overloads:

  • - (::Vertx::DnsClient) createDnsClient(options)

    Parameters:

    • options (Hash{String => Object})
      the client options
  • - (::Vertx::DnsClient) createDnsClient(port, host)

    Parameters:

    • port (Fixnum)
      the port
    • host (String)
      the host

Returns:



454
455
456
457
458
459
460
461
462
463
464
465
466
467
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 454

def create_dns_client(*args)
  if !block_given? && args[0] == nil && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDnsClient, []).call(),::Vertx::DnsClient)
  elsif args[0].class == Hash && !block_given? && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDnsClient, [Java::IoVertxCoreDns::DnsClientOptions.java_class]).call(Java::IoVertxCoreDns::DnsClientOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::DnsClient)
  elsif args[0].class == Fixnum && args[1].class == String && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDnsClient, [Java::int.java_class,Java::java.lang.String.java_class]).call(args[0],args[1]),::Vertx::DnsClient)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_dns_client(#{args[0]},#{args[1]})"
  end
end

- (::Vertx::HttpClient) createHttpClient - (::Vertx::HttpClient) createHttpClient(options)

Create a HTTP/HTTPS client using the specified options

Overloads:

  • - (::Vertx::HttpClient) createHttpClient(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



373
374
375
376
377
378
379
380
381
382
383
384
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 373

def create_http_client(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpClient, []).call(),::Vertx::HttpClient)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpClient, [Java::IoVertxCoreHttp::HttpClientOptions.java_class]).call(Java::IoVertxCoreHttp::HttpClientOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::HttpClient)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_http_client(#{args[0]})"
  end
end

- (::Vertx::HttpServer) createHttpServer - (::Vertx::HttpServer) createHttpServer(options)

Create an HTTP/HTTPS server using the specified options

Overloads:

  • - (::Vertx::HttpServer) createHttpServer(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



171
172
173
174
175
176
177
178
179
180
181
182
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 171

def create_http_server(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpServer, []).call(),::Vertx::HttpServer)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpServer, [Java::IoVertxCoreHttp::HttpServerOptions.java_class]).call(Java::IoVertxCoreHttp::HttpServerOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::HttpServer)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_http_server(#{args[0]})"
  end
end

- (::Vertx::NetClient) createNetClient - (::Vertx::NetClient) createNetClient(options)

Create a TCP/SSL client using the specified options

Overloads:

  • - (::Vertx::NetClient) createNetClient(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



188
189
190
191
192
193
194
195
196
197
198
199
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 188

def create_net_client(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetClient, []).call(),::Vertx::NetClient)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetClient, [Java::IoVertxCoreNet::NetClientOptions.java_class]).call(Java::IoVertxCoreNet::NetClientOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::NetClient)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_net_client(#{args[0]})"
  end
end

- (::Vertx::NetServer) createNetServer - (::Vertx::NetServer) createNetServer(options)

Create a TCP/SSL server using the specified options

Overloads:

  • - (::Vertx::NetServer) createNetServer(options)

    Parameters:

    • options (Hash{String => Object})
      the options to use

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 74

def create_net_server(*args)
  if !block_given? && args[0] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetServer, []).call(),::Vertx::NetServer)
  elsif args[0].class == Hash && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetServer, [Java::IoVertxCoreNet::NetServerOptions.java_class]).call(Java::IoVertxCoreNet::NetServerOptions.new(::Vertx::Util::Utils.to_json_object(args[0]))),::Vertx::NetServer)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_net_server(#{args[0]})"
  end
end

- (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name) - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize) - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize, maxExecuteTime) - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize, maxExecuteTime, maxExecuteTimeUnit)

Create a named worker executor, the executor should be closed when it's not needed anymore to release resources.

This method can be called mutiple times with the same name. Executors with the same name will share the same worker pool. The worker pool size , max execute time and unit of max execute time are set when the worker pool is created and won't change after.

The worker pool is released when all the WorkerExecutor sharing the same name are closed.

Overloads:

  • - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name)

    Parameters:

    • name (String)
  • - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize)

    Parameters:

    • name (String)
    • poolSize (Fixnum)
  • - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize, maxExecuteTime)

    Parameters:

    • name (String)
    • poolSize (Fixnum)
    • maxExecuteTime (Fixnum)
  • - (::Vertx::WorkerExecutor) createSharedWorkerExecutor(name, poolSize, maxExecuteTime, maxExecuteTimeUnit)

    Parameters:

    • name (String)
      the name of the worker executor
    • poolSize (Fixnum)
      the size of the pool
    • maxExecuteTime (Fixnum)
      the value of max worker execute time
    • maxExecuteTimeUnit (:NANOSECONDS, :MICROSECONDS, :MILLISECONDS, :SECONDS, :MINUTES, :HOURS, :DAYS)
      the value of unit of max worker execute time

Returns:



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 352

def create_shared_worker_executor(*args)
  if args[0].class == String && !block_given? && args[1] == nil && args[2] == nil && args[3] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class]).call(args[0]),::Vertx::WorkerExecutor)
  elsif args[0].class == String && args[1].class == Fixnum && !block_given? && args[2] == nil && args[3] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class,Java::int.java_class]).call(args[0],args[1]),::Vertx::WorkerExecutor)
  elsif args[0].class == String && args[1].class == Fixnum && args[2].class == Fixnum && !block_given? && args[3] == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class,Java::int.java_class,Java::long.java_class]).call(args[0],args[1],args[2]),::Vertx::WorkerExecutor)
  elsif args[0].class == String && args[1].class == Fixnum && args[2].class == Fixnum && args[3].class == Symbol && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class,Java::int.java_class,Java::long.java_class,Java::JavaUtilConcurrent::TimeUnit.java_class]).call(args[0],args[1],args[2],Java::JavaUtilConcurrent::TimeUnit.valueOf(args[3].to_s)),::Vertx::WorkerExecutor)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling create_shared_worker_executor(#{args[0]},#{args[1]},#{args[2]},#{args[3]})"
  end
end

- (void) deployVerticle(name, completionHandler) { ... } - (void) deployVerticle(name, options, completionHandler) { ... }

This method returns an undefined value.

Like #deploy_verticle but => Object} are provided to configure the deployment.

Overloads:

  • - (void) deployVerticle(name, completionHandler) { ... }

    Parameters:

    • name (String)
      The identifier

    Yields:

    • a handler which will be notified when the deployment is complete
  • - (void) deployVerticle(name, options, completionHandler) { ... }

    Parameters:

    • name (String)
      the name
    • options (Hash{String => Object})
      the deployment options.

    Yields:

    • a handler which will be notified when the deployment is complete


96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 96

def deploy_verticle(*args)
  if args[0].class == String && true && args[1] == nil
    if (block_given?)
      return @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future, nil)
    end
  elsif args[0].class == String && args[1].class == Hash && true
    if (block_given?)
      return @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::DeploymentOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],Java::IoVertxCore::DeploymentOptions.new(::Vertx::Util::Utils.to_json_object(args[1])),block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::DeploymentOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],Java::IoVertxCore::DeploymentOptions.new(::Vertx::Util::Utils.to_json_object(args[1])),block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future, nil)
    end
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling deploy_verticle(#{args[0]},#{args[1]})"
  end
end

- (Set<String>) deploymentIDs

Return a Set of deployment IDs for the currently deployed deploymentIDs.

Returns:

  • (Set<String>)
    Set of deployment IDs


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

def deployment_i_ds
  if !block_given?
    return ::Vertx::Util::Utils.to_set(@j_del.java_method(:deploymentIDs, []).call()).map! { |elt| elt }
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling deployment_i_ds()"
  end
end

- (::Vertx::EventBus) eventBus

Get the event bus object. There is a single instance of EventBus per Vertx instance.

Returns:



153
154
155
156
157
158
159
160
161
162
163
164
165
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 153

def event_bus
  if !block_given?
    if @cached_event_bus != nil
      return @cached_event_bus
    end
    return @cached_event_bus = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:eventBus, []).call(),::Vertx::EventBus)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling event_bus()"
  end
end

- (self) exceptionHandler(handler) { ... }

Set a default exception handler for Context, set on at creation.

Yields:

  • the exception handler

Returns:

  • (self)


587
588
589
590
591
592
593
594
595
596
597
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 587

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
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling exception_handler()"
  end
end

- (void) executeBlocking(blockingCodeHandler, resultHandler) { ... } - (void) executeBlocking(blockingCodeHandler, ordered, resultHandler) { ... }

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.

In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on the this context and not on the worker thread.

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 Context#run_on_context

Overloads:

  • - (void) executeBlocking(blockingCodeHandler, resultHandler) { ... }

    Parameters:

    • blockingCodeHandler (Proc)

    Yields:

  • - (void) executeBlocking(blockingCodeHandler, ordered, resultHandler) { ... }

    Parameters:

    • blockingCodeHandler (Proc)
      handler representing the blocking code to run
    • ordered (true, false)
      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


513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 513

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

- (::Vertx::FileSystem) fileSystem

Get the filesystem object. There is a single instance of FileSystem per Vertx instance.

Returns:



278
279
280
281
282
283
284
285
286
287
288
289
290
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 278

def file_system
  if !block_given?
    if @cached_file_system != nil
      return @cached_file_system
    end
    return @cached_file_system = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:fileSystem, []).call(),::Vertx::FileSystem)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling file_system()"
  end
end

- (::Vertx::Context) getOrCreateContext

Gets the current context, or creates one if there isn't one

Returns:



573
574
575
576
577
578
579
580
581
582
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 573

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

- (true, false) isMetricsEnabled

Whether the metrics are enabled for this measured object

Returns:

  • (true, false)
    true if metrics are enabled


265
266
267
268
269
270
271
272
273
274
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 265

def metrics_enabled?
  if !block_given?
    return @j_del.java_method(:isMetricsEnabled, []).call()
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling metrics_enabled?()"
  end
end

- (true, false) isNativeTransportEnabled

Returns whether the native transport is used

Returns:

  • (true, false)
    whether the native transport is used


316
317
318
319
320
321
322
323
324
325
326
327
328
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 316

def native_transport_enabled?
  if !block_given?
    if @cached_is_native_transport_enabled != nil
      return @cached_is_native_transport_enabled
    end
    return @cached_is_native_transport_enabled = @j_del.java_method(:isNativeTransportEnabled, []).call()
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling native_transport_enabled?()"
  end
end

- (::Vertx::TimeoutStream) periodicStream(delay)

Returns a periodic timer as a read stream. The timer will be fired every delay milliseconds after the has been called.

Parameters:

  • delay (Fixnum)
    the delay in milliseconds, after which the timer will fire

Returns:



390
391
392
393
394
395
396
397
398
399
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 390

def periodic_stream(*args)
  if args[0].class == Fixnum && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:periodicStream, [Java::long.java_class]).call(args[0]),::Vertx::TimeoutStream)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling periodic_stream(#{args[0]})"
  end
end

- (void) runOnContext(action) { ... }

This method returns an undefined value.

Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.

Yields:

  • - a handler representing the action to execute


473
474
475
476
477
478
479
480
481
482
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 473

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

- (Fixnum) setPeriodic(delay, handler) { ... }

Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.

Parameters:

  • delay (Fixnum)
    the delay in milliseconds, after which the timer will fire

Yields:

  • the handler that will be called with the timer ID when the timer fires

Returns:

  • (Fixnum)
    the unique ID of the timer


422
423
424
425
426
427
428
429
430
431
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 422

def set_periodic(*args)
  if args[0].class == Fixnum && true
    return @j_del.java_method(:setPeriodic, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],(Proc.new { |event| yield(event) unless !block_given? }))
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling set_periodic(#{args[0]})"
  end
end

- (Fixnum) setTimer(delay, handler) { ... }

Set a one-shot timer to fire after delay milliseconds, at which point handler will be called with the id of the timer.

Parameters:

  • delay (Fixnum)
    the delay in milliseconds, after which the timer will fire

Yields:

  • the handler that will be called with the timer ID when the timer fires

Returns:

  • (Fixnum)
    the unique ID of the timer


543
544
545
546
547
548
549
550
551
552
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 543

def set_timer(*args)
  if args[0].class == Fixnum && true
    return @j_del.java_method(:setTimer, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],(Proc.new { |event| yield(event) unless !block_given? }))
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling set_timer(#{args[0]})"
  end
end

- (::Vertx::SharedData) sharedData

Get the shared data object. There is a single instance of SharedData per Vertx instance.

Returns:



403
404
405
406
407
408
409
410
411
412
413
414
415
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 403

def shared_data
  if !block_given?
    if @cached_shared_data != nil
      return @cached_shared_data
    end
    return @cached_shared_data = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:sharedData, []).call(),::Vertx::SharedData)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling shared_data()"
  end
end

- (::Vertx::TimeoutStream) timerStream(delay)

Returns a one-shot timer as a read stream. The timer will be fired after delay milliseconds after the has been called.

Parameters:

  • delay (Fixnum)
    the delay in milliseconds, after which the timer will fire

Returns:



252
253
254
255
256
257
258
259
260
261
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 252

def timer_stream(*args)
  if args[0].class == Fixnum && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:timerStream, [Java::long.java_class]).call(args[0]),::Vertx::TimeoutStream)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling timer_stream(#{args[0]})"
  end
end

- (void) undeploy(deploymentID, completionHandler) { ... }

This method returns an undefined value.

Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.

Parameters:

  • deploymentID (String)
    the deployment ID

Yields:

  • a handler which will be notified when the undeployment is complete


603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 603

def undeploy(*args)
  if args[0].class == String && true
    if (block_given?)
      return @j_del.java_method(:undeploy, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      @j_del.java_method(:undeploy, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future, nil)
    end
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling undeploy(#{args[0]})"
  end
end