Class List Method List File List

# Class: Vertx::HttpServerRequest

Inherits:
  Object
  - Object
  - Vertx::HttpServerRequest
  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)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (String) absolute_uri
  The absolute URI corresponding to the the HTTP request.
- - (self) body_handler { ... }
  Convenience method for receiving the entire request body in one piece.
- - (Fixnum) bytes_read
  The total number of bytes read for the body of the request.
- - (::Vertx::HttpConnection) connection
  The HttpConnection associated with this request.
- - (self) custom_frame_handler { ... }
  Set a custom frame handler.
- - (self) end_handler { ... }
- - (true, false) ended?
  Has the request ended? I.e.
- - (self) exception_handler { ... }
- - (true, false) expect_multipart?
  True if we are expecting a multi-part body for this request.
- - (self) fetch(amount = nil)
- - (::Vertx::MultiMap) form_attributes
  Returns a map of all form attributes in the request.
- - (String) get_form_attribute(attributeName = nil)
  Return the first form attribute value with the specified name.
- - (String) get_header(headerName = nil)
  Return the first header value with the specified name.
- - (String) get_param(paramName = nil)
  Return the first param value with the specified name.
- - (self) handler { ... }
- - (::Vertx::MultiMap) headers
  The headers in the request.
- - (String) host
  The request host.
- - (::Vertx::SocketAddress) local_address
  The local (server side) address of the server that handles the request.
- - (:OPTIONS, ...) method
  The HTTP method for the request.
- - (::Vertx::NetSocket) net_socket
  Get a net socket for the underlying connection of this request.
- - (::Vertx::MultiMap) params
  The query parameters in the request.
- - (String) path
  The path part of the uri.
- - (self) pause
- - (::Vertx::Pipe) pipe
  Pause this stream and return a to transfer the elements of this stream to a destination .
- - (void) pipe_to(dst = nil) { ... }
  Pipe this ReadStream to the WriteStream.
- - (String) query
  The query part of the uri.
- - (String) raw_method
  The HTTP method as sent by the client.
- - (::Vertx::SocketAddress) remote_address
  The remote (client side) address of the request.
- - (::Vertx::HttpServerResponse) response
  The response.
- - (self) resume
- - (String) scheme
  The scheme of the request.
- - (self) set_expect_multipart(expect = nil)
  Call this with true if you are expecting a multi-part body to be submitted in the request.
- - (true, false) ssl?
  True if this NetSocket is encrypted via SSL/TLS.
- - (Hash) stream_priority
  The priority of the associated HTTP/2 stream for HTTP/2 otherwise null.
- - (self) stream_priority_handler { ... }
  Set an handler for stream priority changes This is not implemented for HTTP/1.x.
- - (::Vertx::ServerWebSocket) upgrade
  Upgrade the connection to a WebSocket connection.
- - (self) upload_handler { ... }
  Set an upload handler.
- - (String) uri
  The URI of the request.
- - (:HTTP_1_0, ...) version
  The HTTP version of the request.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    38
    39
    40
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 38

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

### + (`Object`) j_api_type

    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 self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    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_class
      Java::IoVertxCoreHttp::HttpServerRequest.java_class
    end

### + (`Object`) unwrap(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.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    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.wrap(obj)
      HttpServerRequest.new(obj)
    end

## Instance Method Details

### - (`String`) absolute_uri

Returns the absolute URI corresponding to the the HTTP request

Returns:

- (`String`) —
  the absolute URI corresponding to the the HTTP request

Raises:

- (`ArgumentError`)

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

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

### - (`self`) body_handler { ... }

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

Raises:

- (`ArgumentError`)

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

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

### - (`Fixnum`) bytes_read

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.

Raises:

- (`ArgumentError`)

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

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

### - (`::Vertx::HttpConnection`) connection

Returns the Vertx::HttpConnection associated with this request

Returns:

- (`::Vertx::HttpConnection`) —
  the Vertx::HttpConnection associated with this request

Raises:

- (`ArgumentError`)

    412
    413
    414
    415
    416
    417
    418
    419
    420
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 412

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

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

Raises:

- (`ArgumentError`)

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

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

### - (`self`) end_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

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

Returns:

- (`true`, `false`) —
  true if ended

Raises:

- (`ArgumentError`)

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

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

### - (`self`) exception_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    82
    83
    84
    85
    86
    87
    88
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 82

    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

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

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.

Raises:

- (`ArgumentError`)

    339
    340
    341
    342
    343
    344
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 339

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

### - (`self`) fetch(amount = nil)

Parameters:

- amount (`Fixnum`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`::Vertx::MultiMap`) form_attributes

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:

- (`::Vertx::MultiMap`) —
  the form attributes

Raises:

- (`ArgumentError`)

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

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

### - (`String`) get_form_attribute(attributeName = nil)

Return the first form attribute value with the specified name

Parameters:

- attributeName (`String`) (defaults to: `nil`) —
  the attribute name

Returns:

- (`String`) —
  the attribute value

Raises:

- (`ArgumentError`)

    375
    376
    377
    378
    379
    380
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 375

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

### - (`String`) get_header(headerName = nil)

Return the first header value with the specified name

Parameters:

- headerName (`String`) (defaults to: `nil`) —
  the header name

Returns:

- (`String`) —
  the header value

Raises:

- (`ArgumentError`)

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

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

### - (`String`) get_param(paramName = nil)

Return the first param value with the specified name

Parameters:

- paramName (`String`) (defaults to: `nil`) —
  the param name

Returns:

- (`String`) —
  the param value

Raises:

- (`ArgumentError`)

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

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

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

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`::Vertx::MultiMap`) headers

Returns the headers in the request.

Returns:

- (`::Vertx::MultiMap`) —
  the headers in the request.

Raises:

- (`ArgumentError`)

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

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

Raises:

- (`ArgumentError`)

    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 189

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

### - (`::Vertx::SocketAddress`) local_address

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

Returns:

- (`::Vertx::SocketAddress`) —
  the local (server side) address of the server that handles the request

Raises:

- (`ArgumentError`)

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

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

Raises:

- (`ArgumentError`)

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

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

### - (`::Vertx::NetSocket`) net_socket

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:

- (`::Vertx::NetSocket`) —
  the net socket

Raises:

- (`ArgumentError`)

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

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

### - (`::Vertx::MultiMap`) params

Returns the query parameters in the request

Returns:

- (`::Vertx::MultiMap`) —
  the query parameters in the request

Raises:

- (`ArgumentError`)

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

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

Raises:

- (`ArgumentError`)

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

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

### - (`self`) pause

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

    def pause
      if !block_given?
        @j_del.java_method(:pause, []).call()
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pause()"
    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:

- (`::Vertx::Pipe`) —
  a pipe

Raises:

- (`ArgumentError`)

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

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

### - (`void`) pipe_to(dst = nil) { ... }

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:

- dst (`::Vertx::WriteStream`) (defaults to: `nil`) —
  the destination write stream

Yields:

Raises:

- (`ArgumentError`)

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

    def pipe_to(dst=nil)
      if dst.class.method_defined?(:j_del) && !block_given?
        return @j_del.java_method(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class]).call(dst.j_del)
      elsif dst.class.method_defined?(:j_del) && block_given?
        return @j_del.java_method(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class,Java::IoVertxCore::Handler.java_class]).call(dst.j_del,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
      end
      raise ArgumentError, "Invalid arguments when calling pipe_to(#{dst})"
    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

Raises:

- (`ArgumentError`)

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

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

### - (`String`) raw_method

Returns the HTTP method as sent by the client

Returns:

- (`String`) —
  the HTTP method as sent by the client

Raises:

- (`ArgumentError`)

    147
    148
    149
    150
    151
    152
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 147

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

### - (`::Vertx::SocketAddress`) remote_address

Returns the remote (client side) address of the request

Returns:

- (`::Vertx::SocketAddress`) —
  the remote (client side) address of the request

Raises:

- (`ArgumentError`)

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

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

- (`::Vertx::HttpServerResponse`) —
  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.

Raises:

- (`ArgumentError`)

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

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

### - (`self`) resume

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`String`) scheme

Returns the scheme of the request

Returns:

- (`String`) —
  the scheme of the request

Raises:

- (`ArgumentError`)

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

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

### - (`self`) set_expect_multipart(expect = nil)

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`) (defaults to: `nil`) —
  true - if you are expecting a multi-part body

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

Returns true if this NetSocket is encrypted via SSL/TLS

Returns:

- (`true`, `false`) —
  true if this NetSocket is encrypted via SSL/TLS

Raises:

- (`ArgumentError`)

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

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

### - (`Hash`) stream_priority

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

Returns:

- (`Hash`) —
  the priority of the associated HTTP/2 stream for HTTP/2 otherwise `null`

Raises:

- (`ArgumentError`)

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

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

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

Raises:

- (`ArgumentError`)

    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 433

    def stream_priority_handler
      if block_given?
        @j_del.java_method(:streamPriorityHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(event != nil ? JSON.parse(event.toJson.encode) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling stream_priority_handler()"
    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:

- (`::Vertx::ServerWebSocket`) —
  the WebSocket

Raises:

- (`ArgumentError`)

    386
    387
    388
    389
    390
    391
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 386

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

### - (`self`) upload_handler { ... }

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

Raises:

- (`ArgumentError`)

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

    def upload_handler
      if block_given?
        @j_del.java_method(:uploadHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::HttpServerFileUpload)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling upload_handler()"
    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

Raises:

- (`ArgumentError`)

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

    def uri
      if !block_given?
        return @j_del.java_method(:uri, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling uri()"
    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

Raises:

- (`ArgumentError`)

    133
    134
    135
    136
    137
    138
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/http_server_request.rb', line 133

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