Class List Method List File List

# Class: Vertx::HttpServerRequest

Inherits:
  Object
  - Object
  - Vertx::HttpServerRequest
  show all
Includes:
  ReadStream
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/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.

## Instance Method Summary (collapse)

- - (String) absolute_uri
  @return the absolute URI corresponding to the the HTTP request.
- - (self) body_handler { ... }
  Convenience method for receiving the entire request body in one piece.
- - (::Vertx::HttpConnection) connection
  @return 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?
  @return true if we are expecting a multi-part body for this request.
- - (::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
  @return the headers in the request.
- - (String) host
  @return the request host.
- - (::Vertx::SocketAddress) local_address
  @return the local (server side) address of the server that handles the request.
- - (:OPTIONS, ...) method
  @return the HTTP method for the request.
- - (::Vertx::NetSocket) net_socket
  Get a net socket for the underlying connection of this request.
- - (::Vertx::MultiMap) params
  @return the query parameters in the request.
- - (String) path
  @return The path part of the uri.
- - (self) pause
- - (String) query
  @return the query part of the uri.
- - (String) raw_method
  @return the HTTP method as sent by the client.
- - (::Vertx::SocketAddress) remote_address
  @return the remote (client side) address of the request.
- - (::Vertx::HttpServerResponse) response
  @return the response.
- - (self) resume
- - (String) scheme
  @return 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?
  @return true if this NetSocket is encrypted via SSL/TLS.
- - (::Vertx::ServerWebSocket) upgrade
  Upgrade the connection to a WebSocket connection.
- - (self) upload_handler { ... }
  Set an upload handler.
- - (String) uri
  @return the URI of the request.
- - (:HTTP_1_0, ...) version
  @return the HTTP version of the request.

## Instance Method Details

### - (`String`) absolute_uri

@return the absolute URI corresponding to the the HTTP request

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    226
    227
    228
    229
    230
    231
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 226

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

    238
    239
    240
    241
    242
    243
    244
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 238

    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

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

@return the Vertx::HttpConnection associated with this request

Returns:

- (`::Vertx::HttpConnection`)

Raises:

- (`ArgumentError`)

    349
    350
    351
    352
    353
    354
    355
    356
    357
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 349

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

    340
    341
    342
    343
    344
    345
    346
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 340

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

    71
    72
    73
    74
    75
    76
    77
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 71

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

    330
    331
    332
    333
    334
    335
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 330

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

    37
    38
    39
    40
    41
    42
    43
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 37

    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?

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

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    275
    276
    277
    278
    279
    280
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 275

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

    299
    300
    301
    302
    303
    304
    305
    306
    307
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 299

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

    311
    312
    313
    314
    315
    316
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 311

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

    176
    177
    178
    179
    180
    181
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 176

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

    196
    197
    198
    199
    200
    201
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 196

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

    46
    47
    48
    49
    50
    51
    52
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 46

    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

@return the headers in the request.

Returns:

- (`::Vertx::MultiMap`)

Raises:

- (`ArgumentError`)

    164
    165
    166
    167
    168
    169
    170
    171
    172
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 164

    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

@return the request host. For HTTP2 it returns the pseudo header otherwise it returns the header

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    144
    145
    146
    147
    148
    149
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 144

    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

@return the local (server side) address of the server that handles the request

Returns:

- (`::Vertx::SocketAddress`)

Raises:

- (`ArgumentError`)

    215
    216
    217
    218
    219
    220
    221
    222
    223
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 215

    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

@return the HTTP method for the request.

Returns:

- (`:OPTIONS`, `:GET`, `:HEAD`, `:POST`, `:PUT`, `:DELETE`, `:TRACE`, `:CONNECT`, `:PATCH`, `:OTHER`)

Raises:

- (`ArgumentError`)

    88
    89
    90
    91
    92
    93
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 88

    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.

USE THIS WITH CAUTION!

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. Writing to the socket directly if you don't know what you're doing can easily break the HTTP protocol.

Returns:

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

Raises:

- (`ArgumentError`)

    253
    254
    255
    256
    257
    258
    259
    260
    261
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 253

    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

@return the query parameters in the request

Returns:

- (`::Vertx::MultiMap`)

Raises:

- (`ArgumentError`)

    184
    185
    186
    187
    188
    189
    190
    191
    192
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 184

    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

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

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    128
    129
    130
    131
    132
    133
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 128

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

    54
    55
    56
    57
    58
    59
    60
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 54

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

### - (`String`) query

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

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    136
    137
    138
    139
    140
    141
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 136

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

### - (`String`) raw_method

@return the HTTP method as sent by the client

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    96
    97
    98
    99
    100
    101
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 96

    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

@return the remote (client side) address of the request

Returns:

- (`::Vertx::SocketAddress`)

Raises:

- (`ArgumentError`)

    204
    205
    206
    207
    208
    209
    210
    211
    212
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 204

    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

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

Raises:

- (`ArgumentError`)

    153
    154
    155
    156
    157
    158
    159
    160
    161
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 153

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

    62
    63
    64
    65
    66
    67
    68
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 62

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

### - (`String`) scheme

@return the scheme of the request

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    112
    113
    114
    115
    116
    117
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 112

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

    266
    267
    268
    269
    270
    271
    272
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 266

    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?

@return true if this NetSocket is encrypted via SSL/TLS

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    104
    105
    106
    107
    108
    109
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 104

    def ssl?
      if !block_given?
        return @j_del.java_method(:isSSL, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling ssl?()"
    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 handlers are set on the Http server, and can only be used during the upgrade request during the WebSocket handshake.

Returns:

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

Raises:

- (`ArgumentError`)

    322
    323
    324
    325
    326
    327
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 322

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

    285
    286
    287
    288
    289
    290
    291
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 285

    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

@return the URI of the request. This is usually a relative URI

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    120
    121
    122
    123
    124
    125
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 120

    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

@return the HTTP version of the request

Returns:

- (`:HTTP_1_0`, `:HTTP_1_1`, `:HTTP_2`)

Raises:

- (`ArgumentError`)

    80
    81
    82
    83
    84
    85
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/http_server_request.rb', line 80

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