Class: Vertx::HttpServerRequest

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

Overview

Represents a server-side HTTP request.

Instances are created for each request and passed to the user via a handler.

Each instance of this class is associated with a corresponding HttpServerResponse instance via #response.

It implements ReadStream so it can be used with Pump to pump data with flow control.

Constant Summary

@@j_api_type =
Object.new

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Boolean) accept?(obj)

Returns:

  • (Boolean)


41
42
43
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 41

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

+ (Object) j_api_type



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

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class



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

def self.j_class
  Java::IoVertxCoreHttp::HttpServerRequest.java_class
end

+ (Object) unwrap(obj)



47
48
49
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 47

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

+ (Object) wrap(obj)



44
45
46
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 44

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

Instance Method Details

- (String) absoluteURI

Returns the absolute URI corresponding to the the HTTP request

Returns:

  • (String)
    the absolute URI corresponding to the the HTTP request


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

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

- (::Vertx::HttpServerRequest) body(handler) { ... }

Same as #body but with an handler called when the operation completes

Yields:

Returns:



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

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

- (self) bodyHandler(bodyHandler) { ... }

Convenience method for receiving the entire request body in one piece.

This saves the user having to manually setting a data and end handler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

Yields:

  • This handler will be called after all the body has been received

Returns:

  • (self)


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

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

- (Fixnum) bytesRead

Returns the total number of bytes read for the body of the request.

Returns:

  • (Fixnum)
    the total number of bytes read for the body of the request.


482
483
484
485
486
487
488
489
490
491
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 482

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

- (::Vertx::HttpConnection) connection

Returns the Vertx::HttpConnection associated with this request

Returns:



298
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/http_server_request.rb', line 298

def connection
  if !block_given?
    if @cached_connection != nil
      return @cached_connection
    end
    return @cached_connection = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:connection, []).call(),::Vertx::HttpConnection)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling connection()"
  end
end
Returns the number of cookieMap.

Returns:

  • (Fixnum)
    the number of cookieMap.


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/http_server_request.rb', line 560

def cookie_count
  if !block_given?
    return @j_del.java_method(:cookieCount, []).call()
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling cookie_count()"
  end
end
Returns a map of all the cookies.

Returns:



416
417
418
419
420
421
422
423
424
425
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 416

def cookie_map
  if !block_given?
    return Java::IoVertxLangRuby::Helper.adaptingMap(@j_del.java_method(:cookieMap, []).call(), Proc.new { |val| ::Vertx::Util::Utils.safe_create(val,::Vertx::Cookie) }, Proc.new { |val| val.j_del })
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling cookie_map()"
  end
end

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

Set a custom frame handler. The handler will get notified when the http stream receives an custom HTTP/2 frame. HTTP/2 permits extension of the protocol.

Yields:

Returns:

  • (self)


360
361
362
363
364
365
366
367
368
369
370
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 360

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

- (self) endHandler(endHandler) { ... }

Yields:

Returns:

  • (self)


597
598
599
600
601
602
603
604
605
606
607
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 597

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

- (true, false) isEnded

Has the request ended? I.e. has the entire request, including the body been read?

Returns:

  • (true, false)
    true if ended


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

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

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

Yields:

Returns:

  • (self)


655
656
657
658
659
660
661
662
663
664
665
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 655

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

- (true, false) isExpectMultipart

Returns true if we are expecting a multi-part body for this request. See #set_expect_multipart.

Returns:

  • (true, false)
    true if we are expecting a multi-part body for this request. See #set_expect_multipart.


584
585
586
587
588
589
590
591
592
593
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 584

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

- (self) fetch(amount)

Parameters:

  • amount (Fixnum)

Returns:

  • (self)


641
642
643
644
645
646
647
648
649
650
651
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 641

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

- (::Vertx::MultiMap) formAttributes

Returns a map of all form attributes in the request.

Be aware that the attributes will only be available after the whole body has been received, i.e. after the request end handler has been called.

#set_expect_multipart must be called first before trying to get the form attributes.

Returns:



215
216
217
218
219
220
221
222
223
224
225
226
227
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 215

def form_attributes
  if !block_given?
    if @cached_form_attributes != nil
      return @cached_form_attributes
    end
    return @cached_form_attributes = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:formAttributes, []).call(),::Vertx::MultiMap)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling form_attributes()"
  end
end
Get the cookie with the specified name.

Parameters:

  • name (String)
    the cookie name

Returns:



112
113
114
115
116
117
118
119
120
121
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 112

def get_cookie(*args)
  if args[0].class == String && !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:getCookie, [Java::java.lang.String.java_class]).call(args[0]),::Vertx::Cookie)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling get_cookie(#{args[0]})"
  end
end

- (String) getFormAttribute(attributeName)

Return the first form attribute value with the specified name

Parameters:

  • attributeName (String)
    the attribute name

Returns:

  • (String)
    the attribute value


548
549
550
551
552
553
554
555
556
557
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 548

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

- (String) getHeader(headerName)

Return the first header value with the specified name

Parameters:

  • headerName (String)
    the header name

Returns:

  • (String)
    the header value


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

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

- (String) getParam(paramName)

Return the first param value with the specified name

Parameters:

  • paramName (String)
    the param name

Returns:

  • (String)
    the param value


430
431
432
433
434
435
436
437
438
439
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 430

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

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

Yields:

Returns:

  • (self)


59
60
61
62
63
64
65
66
67
68
69
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 59

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

- (::Vertx::MultiMap) headers

Returns the headers in the request.

Returns:



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

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

- (String) host

Returns the request host. For HTTP2 it returns the pseudo header otherwise it returns the header

Returns:

  • (String)
    the request host. For HTTP2 it returns the pseudo header otherwise it returns the header


268
269
270
271
272
273
274
275
276
277
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 268

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

- (::Vertx::SocketAddress) localAddress

Returns the local (server side) address of the server that handles the request

Returns:



610
611
612
613
614
615
616
617
618
619
620
621
622
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 610

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

- (:OPTIONS, ...) method

Returns the HTTP method for the request.

Returns:

  • (:OPTIONS, :GET, :HEAD, :POST, :PUT, :DELETE, :TRACE, :CONNECT, :PATCH, :OTHER)
    the HTTP method for the request.


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/http_server_request.rb', line 458

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

- (::Vertx::NetSocket) netSocket

Get a net socket for the underlying connection of this request.

This method must be called before the server response is ended.

With CONNECT requests, a 200 response is sent with no content-length header set before returning the socket.


 server.requestHandler(req -> {
   if (req.method() == HttpMethod.CONNECT) {
     // Send a 200 response to accept the connect
     NetSocket socket = req.netSocket();
     socket.handler(buff -> {
       socket.write(buff);
     });
   }
   ...
 });
 

For other HTTP/1 requests once you have called this method, you must handle writing to the connection yourself using the net socket, the server request instance will no longer be usable as normal. USE THIS WITH CAUTION! Writing to the socket directly if you don't know what you're doing can easily break the HTTP protocol.

With HTTP/2, a 200 response is always sent with no content-length header set before returning the socket like in the CONNECT case above.

Returns:



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

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

- (::Vertx::MultiMap) params

Returns the query parameters in the request

Returns:



494
495
496
497
498
499
500
501
502
503
504
505
506
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 494

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

- (String) path

Returns The path part of the uri. For example /somepath/somemorepath/someresource.foo

Returns:

  • (String)
    The path part of the uri. For example /somepath/somemorepath/someresource.foo


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

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

- (self) pause

Returns:

  • (self)


533
534
535
536
537
538
539
540
541
542
543
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 533

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

- (::Vertx::Pipe) pipe

Pause this stream and return a to transfer the elements of this stream to a destination .

The stream will be resumed when the pipe will be wired to a WriteStream.

Returns:



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

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

- (void) pipeTo(dst, handler) { ... }

This method returns an undefined value.

Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

Parameters:

Yields:



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

def pipe_to(*args)
  if args[0].class.method_defined?(:j_del) && true
    if (block_given?)
      return @j_del.java_method(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0].j_del,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(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0].j_del,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 pipe_to(#{args[0]})"
  end
end

- (String) query

Returns the query part of the uri. For example someparam=32&someotherparam=x

Returns:

  • (String)
    the query part of the uri. For example someparam=32&someotherparam=x


470
471
472
473
474
475
476
477
478
479
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 470

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

- (String) rawMethod

Returns the HTTP method as sent by the client

Returns:

  • (String)
    the HTTP method as sent by the client


230
231
232
233
234
235
236
237
238
239
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 230

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

- (::Vertx::SocketAddress) remoteAddress

Returns the remote (client side) address of the request

Returns:



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

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

- (::Vertx::HttpServerResponse) response

Returns the response. Each instance of this class has an Vertx::HttpServerResponse instance attached to it. This is used to send the response back to the client.

Returns:



625
626
627
628
629
630
631
632
633
634
635
636
637
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 625

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

- (self) resume

Returns:

  • (self)


388
389
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/http_server_request.rb', line 388

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

- (String) scheme

Returns the scheme of the request

Returns:

  • (String)
    the scheme of the request


72
73
74
75
76
77
78
79
80
81
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 72

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

- (self) setExpectMultipart(expect)

Call this with true if you are expecting a multi-part body to be submitted in the request. This must be called before the body of the request has been received

Parameters:

  • expect (true, false)
    true - if you are expecting a multi-part body

Returns:

  • (self)


671
672
673
674
675
676
677
678
679
680
681
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 671

def set_expect_multipart(*args)
  if (args[0].class == TrueClass || args[0].class == FalseClass) && !block_given?
    @j_del.java_method(:setExpectMultipart, [Java::boolean.java_class]).call(args[0])
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling set_expect_multipart(#{args[0]})"
  end
end

- (true, false) isSSL

Returns true if this NetSocket is encrypted via SSL/TLS

Returns:

  • (true, false)
    true if this NetSocket is encrypted via SSL/TLS


684
685
686
687
688
689
690
691
692
693
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 684

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

- (Hash{String => Object}) streamPriority

Returns the priority of the associated HTTP/2 stream for HTTP/2 otherwise null

Returns:

  • (Hash{String => Object})
    the priority of the associated HTTP/2 stream for HTTP/2 otherwise null


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

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

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

Set an handler for stream priority changes

This is not implemented for HTTP/1.x.

Yields:

  • the handler to be called when stream priority changes

Returns:

  • (self)


184
185
186
187
188
189
190
191
192
193
194
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 184

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

- (::Vertx::ServerWebSocket) upgrade

Upgrade the connection to a WebSocket connection.

This is an alternative way of handling WebSockets and can only be used if no WebSocket handler is set on the HttpServer, and can only be used during the upgrade request during the WebSocket handshake.

Returns:



446
447
448
449
450
451
452
453
454
455
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 446

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

- (self) uploadHandler(uploadHandler) { ... }

Set an upload handler. The handler will get notified once a new file upload was received to allow you to deal with the file upload.

Yields:

Returns:

  • (self)


344
345
346
347
348
349
350
351
352
353
354
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 344

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

- (String) uri

Returns the URI of the request. This is usually a relative URI

Returns:

  • (String)
    the URI of the request. This is usually a relative URI


509
510
511
512
513
514
515
516
517
518
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 509

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

- (:HTTP_1_0, ...) version

Returns the HTTP version of the request

Returns:

  • (:HTTP_1_0, :HTTP_1_1, :HTTP_2)
    the HTTP version of the request


521
522
523
524
525
526
527
528
529
530
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 521

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