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) 


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

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

+ (void) clustered_vertx(options = nil) { ... }

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) (defaults to: nil) —
    the options to use

Yields:

  • the result handler that will receive the result

Raises:

  • (ArgumentError) 


92
93
94
95
96
97
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 92

def self.clustered_vertx(options=nil)
  if options.class == Hash && 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(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Vertx) : nil) }))
  end
  raise ArgumentError, "Invalid arguments when calling clustered_vertx(#{options})"
end

+ (::Vertx::Context) current_context

Gets the current context

Returns:

Raises:

  • (ArgumentError) 


100
101
102
103
104
105
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 100

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

+ (Object) j_api_type 



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

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class 



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

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

+ (Object) unwrap(obj) 



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

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

+ (::Vertx::Vertx) vertx(options = nil)

Creates a non clustered instance using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


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 78

def self.vertx(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCore::Vertx.java_method(:vertx, []).call(),::Vertx::Vertx)
  elsif options.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(options))),::Vertx::Vertx)
  end
  raise ArgumentError, "Invalid arguments when calling vertx(#{options})"
end

+ (Object) wrap(obj) 



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

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

Instance Method Details

- (true, false) cancel_timer?(id = nil)

Cancels the timer with the specified id.

Parameters:

  • id (Fixnum) (defaults to: nil) —
    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.

Raises:

  • (ArgumentError) 


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

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

- (void) close { ... }

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.

Raises:

  • (ArgumentError) 


285
286
287
288
289
290
291
292
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 285

def close
  if !block_given?
    return @j_del.java_method(:close, []).call()
  elsif block_given?
    return @j_del.java_method(:close, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
  end
  raise ArgumentError, "Invalid arguments when calling close()"
end

- (true, false) clustered?

Is this Vert.x instance clustered?

Returns:

  • (true, false) —
    true if clustered

Raises:

  • (ArgumentError) 


333
334
335
336
337
338
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 333

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

- (::Vertx::DatagramSocket) create_datagram_socket(options = nil)

Create a datagram socket using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


161
162
163
164
165
166
167
168
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 161

def create_datagram_socket(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDatagramSocket, []).call(),::Vertx::DatagramSocket)
  elsif options.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(options))),::Vertx::DatagramSocket)
  end
  raise ArgumentError, "Invalid arguments when calling create_datagram_socket(#{options})"
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) —
      the client options
  • - (::Vertx::DnsClient) createDnsClient(port, host)

    Parameters:

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

Returns:

Raises:

  • (ArgumentError) 


200
201
202
203
204
205
206
207
208
209
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 200

def create_dns_client(param_1=nil,param_2=nil)
  if !block_given? && param_1 == nil && param_2 == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createDnsClient, []).call(),::Vertx::DnsClient)
  elsif param_1.class == Hash && !block_given? && param_2 == 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(param_1))),::Vertx::DnsClient)
  elsif param_1.class == Fixnum && param_2.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(param_1,param_2),::Vertx::DnsClient)
  end
  raise ArgumentError, "Invalid arguments when calling create_dns_client(#{param_1},#{param_2})"
end

- (::Vertx::HttpClient) create_http_client(options = nil)

Create a HTTP/HTTPS client using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


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

def create_http_client(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpClient, []).call(),::Vertx::HttpClient)
  elsif options.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(options))),::Vertx::HttpClient)
  end
  raise ArgumentError, "Invalid arguments when calling create_http_client(#{options})"
end

- (::Vertx::HttpServer) create_http_server(options = nil)

Create an HTTP/HTTPS server using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


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

def create_http_server(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createHttpServer, []).call(),::Vertx::HttpServer)
  elsif options.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(options))),::Vertx::HttpServer)
  end
  raise ArgumentError, "Invalid arguments when calling create_http_server(#{options})"
end

- (::Vertx::NetClient) create_net_client(options = nil)

Create a TCP/SSL client using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


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

def create_net_client(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetClient, []).call(),::Vertx::NetClient)
  elsif options.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(options))),::Vertx::NetClient)
  end
  raise ArgumentError, "Invalid arguments when calling create_net_client(#{options})"
end

- (::Vertx::NetServer) create_net_server(options = nil)

Create a TCP/SSL server using the specified options

Parameters:

  • options (Hash) (defaults to: nil) —
    the options to use

Returns:

Raises:

  • (ArgumentError) 


117
118
119
120
121
122
123
124
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 117

def create_net_server(options=nil)
  if !block_given? && options == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createNetServer, []).call(),::Vertx::NetServer)
  elsif options.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(options))),::Vertx::NetServer)
  end
  raise ArgumentError, "Invalid arguments when calling create_net_server(#{options})"
end

- (::Vertx::WorkerExecutor) create_shared_worker_executor(name = nil, poolSize = nil, maxExecuteTime = nil, maxExecuteTimeUnit = nil)

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.

Parameters:

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

Returns:

Raises:

  • (ArgumentError) 


377
378
379
380
381
382
383
384
385
386
387
388
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 377

def create_shared_worker_executor(name=nil,poolSize=nil,maxExecuteTime=nil,maxExecuteTimeUnit=nil)
  if name.class == String && !block_given? && poolSize == nil && maxExecuteTime == nil && maxExecuteTimeUnit == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class]).call(name),::Vertx::WorkerExecutor)
  elsif name.class == String && poolSize.class == Fixnum && !block_given? && maxExecuteTime == nil && maxExecuteTimeUnit == nil
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:createSharedWorkerExecutor, [Java::java.lang.String.java_class,Java::int.java_class]).call(name,poolSize),::Vertx::WorkerExecutor)
  elsif name.class == String && poolSize.class == Fixnum && maxExecuteTime.class == Fixnum && !block_given? && maxExecuteTimeUnit == 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(name,poolSize,maxExecuteTime),::Vertx::WorkerExecutor)
  elsif name.class == String && poolSize.class == Fixnum && maxExecuteTime.class == Fixnum && maxExecuteTimeUnit.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(name,poolSize,maxExecuteTime,Java::JavaUtilConcurrent::TimeUnit.valueOf(maxExecuteTimeUnit.to_s)),::Vertx::WorkerExecutor)
  end
  raise ArgumentError, "Invalid arguments when calling create_shared_worker_executor(#{name},#{poolSize},#{maxExecuteTime},#{maxExecuteTimeUnit})"
end

- (void) deploy_verticle(name = nil, options = nil) { ... }

This method returns an undefined value.

Like #deploy_verticle but Hash are provided to configure the deployment.

Parameters:

  • name (String) (defaults to: nil) —
    the name
  • options (Hash) (defaults to: nil) —
    the deployment options.

Yields:

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

Raises:

  • (ArgumentError) 


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

def deploy_verticle(name=nil,options=nil)
  if name.class == String && !block_given? && options == nil
    return @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class]).call(name)
  elsif name.class == String && block_given? && options == nil
    return @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(name,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
  elsif name.class == String && options.class == Hash && !block_given?
    return @j_del.java_method(:deployVerticle, [Java::java.lang.String.java_class,Java::IoVertxCore::DeploymentOptions.java_class]).call(name,Java::IoVertxCore::DeploymentOptions.new(::Vertx::Util::Utils.to_json_object(options)))
  elsif name.class == String && options.class == Hash && 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(name,Java::IoVertxCore::DeploymentOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
  end
  raise ArgumentError, "Invalid arguments when calling deploy_verticle(#{name},#{options})"
end

- (Set<String>) deployment_i_ds

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

Returns:

  • (Set<String>) —
    Set of deployment IDs

Raises:

  • (ArgumentError) 


325
326
327
328
329
330
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 325

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

- (::Vertx::EventBus) event_bus

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

Returns:

Raises:

  • (ArgumentError) 


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

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
  raise ArgumentError, "Invalid arguments when calling event_bus()"
end

- (self) exception_handler { ... }

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

Yields:

  • the exception handler

Returns:

  • (self)

Raises:

  • (ArgumentError) 


402
403
404
405
406
407
408
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 402

def exception_handler
  if block_given?
    @j_del.java_method(:exceptionHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.from_throwable(event)) }))
    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 Future#complete or Future#complete method, or the Future#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.

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) 


356
357
358
359
360
361
362
363
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 356

def execute_blocking(blockingCodeHandler=nil,ordered=nil)
  if blockingCodeHandler.class == Proc && block_given? && 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::Future, nil)) }),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.from_object(ar.result) : nil) }))
  elsif blockingCodeHandler.class == Proc && (ordered.class == TrueClass || ordered.class == FalseClass) && 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| blockingCodeHandler.call(::Vertx::Util::Utils.safe_create(event,::Vertx::Future, nil)) }),ordered,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.from_object(ar.result) : nil) }))
  end
  raise ArgumentError, "Invalid arguments when calling execute_blocking(#{blockingCodeHandler},#{ordered})"
end

- (::Vertx::FileSystem) file_system

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

Returns:

Raises:

  • (ArgumentError) 


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

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
  raise ArgumentError, "Invalid arguments when calling file_system()"
end

- (::Vertx::Context) get_or_create_context

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

Returns:

Raises:

  • (ArgumentError) 


108
109
110
111
112
113
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 108

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

- (true, false) metrics_enabled?

Whether the metrics are enabled for this measured object

Returns:

  • (true, false) —
    true if metrics are enabled

Raises:

  • (ArgumentError) 


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

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

- (true, false) native_transport_enabled?

Returns whether the native transport is used

Returns:

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

Raises:

  • (ArgumentError) 


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

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
  raise ArgumentError, "Invalid arguments when calling native_transport_enabled?()"
end

- (::Vertx::TimeoutStream) periodic_stream(delay = nil)

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

Parameters:

  • delay (Fixnum) (defaults to: nil) —
    the delay in milliseconds, after which the timer will fire

Returns:

Raises:

  • (ArgumentError) 


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

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

- (void) run_on_context { ... }

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

Raises:

  • (ArgumentError) 


276
277
278
279
280
281
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 276

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

- (Fixnum) set_periodic(delay = nil) { ... }

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) (defaults to: nil) —
    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

Raises:

  • (ArgumentError) 


247
248
249
250
251
252
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 247

def set_periodic(delay=nil)
  if delay.class == Fixnum && block_given?
    return @j_del.java_method(:setPeriodic, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(delay,(Proc.new { |event| yield(event) }))
  end
  raise ArgumentError, "Invalid arguments when calling set_periodic(#{delay})"
end

- (Fixnum) set_timer(delay = nil) { ... }

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) (defaults to: nil) —
    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

Raises:

  • (ArgumentError) 


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

def set_timer(delay=nil)
  if delay.class == Fixnum && block_given?
    return @j_del.java_method(:setTimer, [Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(delay,(Proc.new { |event| yield(event) }))
  end
  raise ArgumentError, "Invalid arguments when calling set_timer(#{delay})"
end

- (::Vertx::SharedData) shared_data

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

Returns:

Raises:

  • (ArgumentError) 


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

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
  raise ArgumentError, "Invalid arguments when calling shared_data()"
end

- (::Vertx::TimeoutStream) timer_stream(delay = nil)

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) (defaults to: nil) —
    the delay in milliseconds, after which the timer will fire

Returns:

Raises:

  • (ArgumentError) 


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

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

- (void) undeploy(deploymentID = nil) { ... }

This method returns an undefined value.

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

Parameters:

  • deploymentID (String) (defaults to: nil) —
    the deployment ID

Yields:

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

Raises:

  • (ArgumentError) 


315
316
317
318
319
320
321
322
 
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/vertx.rb', line 315

def undeploy(deploymentID=nil)
  if deploymentID.class == String && !block_given?
    return @j_del.java_method(:undeploy, [Java::java.lang.String.java_class]).call(deploymentID)
  elsif deploymentID.class == String && block_given?
    return @j_del.java_method(:undeploy, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(deploymentID,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
  end
  raise ArgumentError, "Invalid arguments when calling undeploy(#{deploymentID})"
end