Class List Method List File List

# Class: VertxStomp::StompServerHandler

Inherits:
  Object
  - Object
  - VertxStomp::StompServerHandler
  show all
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb

## Overview

STOMP server handler implements the behavior of the STOMP server when a specific event occurs. For instance, if let customize the behavior when specific STOMP frames arrives or when a connection is closed. This class has been designed to let you customize the server behavior. The default implementation is compliant with the STOMP specification. In this default implementation, not acknowledge frames are dropped.

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (::VertxStomp::StompServerHandler) create(vertx = nil)
  Creates an instance of StompServerHandler using the default (compliant) implementation.
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (self) abort_handler { ... }
  Configures the action to execute when a ABORT frame is received.
- - (self) ack_handler { ... }
  Configures the action to execute when a ACK frame is received.
- - (self) auth_provider(handler = nil)
  Configures the to be used to authenticate the user.
- - (self) begin_handler { ... }
  Configures the action to execute when a BEGIN frame is received.
- - (self) bridge(options = nil)
  Configures the STOMP server to act as a bridge with the Vert.x event bus.
- - (self) close_handler { ... }
  Configures the action to execute when a connection with the client is closed.
- - (self) commit_handler { ... }
  Configures the action to execute when a COMMIT frame is received.
- - (self) connect_handler { ... }
  Configures the action to execute when a CONNECT frame is received.
- - (self) destination_factory(factory = nil)
  Configures the DestinationFactory used to create Destination objects.
- - (self) disconnect_handler { ... }
  Configures the action to execute when a DISCONNECT frame is received.
- - (::VertxStomp::Destination) get_destination(destination = nil)
  Gets the destination with the given name.
- - (Array<::VertxStomp::Destination>) get_destinations
  The list of destination managed by the STOMP server.
- - (::VertxStomp::Destination) get_or_create_destination(destination = nil)
  Gets a Destination object if existing, or create a new one.
- - (::VertxAuthCommon::User) get_user_by_session(session = nil)
  Provides for authorization matches on a destination level, this will return the User created by the .
- - (void) handle(event = nil)
  Something has happened, so handle it.
- - (self) nack_handler { ... }
  Configures the action to execute when a NACK frame is received.
- - (self) on_ack(connection = nil, subscribe = nil, messages = nil)
  Method called by single message (client-individual policy) or a set of message (client policy) are acknowledged.
- - (self) on_ack_handler { ... }
  Configures the action to execute when messages are acknowledged.
- - (self) on_authentication_request(connection = nil, login = nil, passcode = nil) { ... }
  Called when the client connects to a server requiring authentication.
- - (void) on_close(connection = nil)
  Called when the connection is closed.
- - (self) on_nack(connection = nil, subscribe = nil, messages = nil)
  Method called by single message (client-individual policy) or a set of message (client policy) are not acknowledged.
- - (self) on_nack_handler { ... }
  Configures the action to execute when messages are not acknowledged.
- - (self) ping_handler { ... }
  Allows customizing the action to do when the server needs to send a `PING` to the client.
- - (self) received_frame_handler { ... }
  Configures a handler that get notified when a STOMP frame is received by the server.
- - (self) send_handler { ... }
  Configures the action to execute when a SEND frame is received.
- - (self) stomp_handler { ... }
  Configures the action to execute when a STOMP frame is received.
- - (self) subscribe_handler { ... }
  Configures the action to execute when a SUBSCRIBE frame is received.
- - (self) unsubscribe_handler { ... }
  Configures the action to execute when a UNSUBSCRIBE frame is received.

## Class Method Details

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

Returns:

- (`Boolean`)

    28
    29
    30
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 28

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

### + (`::VertxStomp::StompServerHandler`) create(vertx = nil)

Creates an instance of VertxStomp::StompServerHandler using the default (compliant) implementation.

Parameters:

- vertx (`::Vertx::Vertx`) (defaults to: `nil`) —
  the vert.x instance to use

Returns:

- (`::VertxStomp::StompServerHandler`) —
  the created VertxStomp::StompServerHandler

Raises:

- (`ArgumentError`)

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

    def self.create(vertx=nil)
      if vertx.class.method_defined?(:j_del) && !block_given?
        return ::Vertx::Util::Utils.safe_create(Java::IoVertxExtStomp::StompServerHandler.java_method(:create, [Java::IoVertxCore::Vertx.java_class]).call(vertx.j_del),::VertxStomp::StompServerHandler)
      end
      raise ArgumentError, "Invalid arguments when calling create(#{vertx})"
    end

### + (`Object`) j_api_type

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

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

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

    def self.j_class
      Java::IoVertxExtStomp::StompServerHandler.java_class
    end

### + (`Object`) unwrap(obj)

    34
    35
    36
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 34

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

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

    31
    32
    33
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 31

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

## Instance Method Details

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

Configures the action to execute when a `ABORT` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

Configures the action to execute when a `ACK` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`self`) auth_provider(handler = nil)

Configures the to be used to authenticate the user.

Parameters:

- handler (`::VertxAuthCommon::AuthProvider`) (defaults to: `nil`) —
  the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    228
    229
    230
    231
    232
    233
    234
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 228

    def auth_provider(handler=nil)
      if handler.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:authProvider, [Java::IoVertxExtAuth::AuthProvider.java_class]).call(handler.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling auth_provider(#{handler})"
    end

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

Configures the action to execute when a `BEGIN` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    165
    166
    167
    168
    169
    170
    171
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 165

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

### - (`self`) bridge(options = nil)

Configures the STOMP server to act as a bridge with the Vert.x event bus.

Parameters:

- options (`Hash`) (defaults to: `nil`) —
  the configuration options

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    336
    337
    338
    339
    340
    341
    342
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 336

    def bridge(options=nil)
      if options.class == Hash && !block_given?
        @j_del.java_method(:bridge, [Java::IoVertxExtStomp::BridgeOptions.java_class]).call(Java::IoVertxExtStomp::BridgeOptions.new(::Vertx::Util::Utils.to_json_object(options)))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling bridge(#{options})"
    end

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

Configures the action to execute when a connection with the client is closed.

Yields:

- the handler

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-stomp/stomp_server_handler.rb', line 125

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

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

Configures the action to execute when a `COMMIT` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

Configures the action to execute when a `CONNECT` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`self`) destination_factory(factory = nil)

Configures the DestinationFactory used to create Destination objects.

Parameters:

- factory (`::VertxStomp::DestinationFactory`) (defaults to: `nil`) —
  the factory

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

    def destination_factory(factory=nil)
      if factory.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:destinationFactory, [Java::IoVertxExtStomp::DestinationFactory.java_class]).call(factory.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling destination_factory(#{factory})"
    end

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

Configures the action to execute when a `DISCONNECT` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`::VertxStomp::Destination`) get_destination(destination = nil)

Gets the destination with the given name.

Parameters:

- destination (`String`) (defaults to: `nil`) —
  the destination

Returns:

- (`::VertxStomp::Destination`) —
  the Destination, `null` if not existing.

Raises:

- (`ArgumentError`)

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

    def get_destination(destination=nil)
      if destination.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:getDestination, [Java::java.lang.String.java_class]).call(destination),::VertxStomp::Destination)
      end
      raise ArgumentError, "Invalid arguments when calling get_destination(#{destination})"
    end

### - (`Array<::VertxStomp::Destination>`) get_destinations

Returns the list of destination managed by the STOMP server. Don't forget the STOMP interprets destination as opaque Strings.

Returns:

- (`Array<::VertxStomp::Destination>`) —
  the list of destination managed by the STOMP server. Don't forget the STOMP interprets destination as opaque Strings.

Raises:

- (`ArgumentError`)

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

    def get_destinations
      if !block_given?
        return @j_del.java_method(:getDestinations, []).call().to_a.map { |elt| ::Vertx::Util::Utils.safe_create(elt,::VertxStomp::Destination) }
      end
      raise ArgumentError, "Invalid arguments when calling get_destinations()"
    end

### - (`::VertxStomp::Destination`) get_or_create_destination(destination = nil)

Gets a Destination object if existing, or create a new one. The creation is delegated to the DestinationFactory.

Parameters:

- destination (`String`) (defaults to: `nil`) —
  the destination

Returns:

- (`::VertxStomp::Destination`) —
  the Destination instance, may have been created.

Raises:

- (`ArgumentError`)

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

    def get_or_create_destination(destination=nil)
      if destination.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:getOrCreateDestination, [Java::java.lang.String.java_class]).call(destination),::VertxStomp::Destination)
      end
      raise ArgumentError, "Invalid arguments when calling get_or_create_destination(#{destination})"
    end

### - (`::VertxAuthCommon::User`) get_user_by_session(session = nil)

Provides for authorization matches on a destination level, this will return the User created by the .

Parameters:

- session (`String`) (defaults to: `nil`) —
  session ID for the server connection.

Returns:

- (`::VertxAuthCommon::User`) —
  null if not authenticated.

Raises:

- (`ArgumentError`)

    219
    220
    221
    222
    223
    224
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 219

    def get_user_by_session(session=nil)
      if session.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:getUserBySession, [Java::java.lang.String.java_class]).call(session),::VertxAuthCommon::User)
      end
      raise ArgumentError, "Invalid arguments when calling get_user_by_session(#{session})"
    end

### - (`void`) handle(event = nil)

This method returns an undefined value.

Something has happened, so handle it.

Parameters:

- event (`::VertxStomp::ServerFrame`) (defaults to: `nil`) —
  the event to handle

Raises:

- (`ArgumentError`)

    46
    47
    48
    49
    50
    51
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 46

    def handle(event=nil)
      if event.class.method_defined?(:j_del) && !block_given?
        return @j_del.java_method(:handle, [Java::IoVertxExtStomp::ServerFrame.java_class]).call(event.j_del)
      end
      raise ArgumentError, "Invalid arguments when calling handle(#{event})"
    end

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

Configures the action to execute when a `NACK` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`self`) on_ack(connection = nil, subscribe = nil, messages = nil)

Method called by single message (client-individual policy) or a set of message (client policy) are acknowledged. Implementations must call the handler configured using #on_ack_handler.

Parameters:

- connection (`::VertxStomp::StompServerConnection`) (defaults to: `nil`) —
  the connection
- subscribe (`Hash`) (defaults to: `nil`) —
  the `SUBSCRIBE` frame
- messages (`Array<Hash>`) (defaults to: `nil`) —
  the acknowledge messages

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

    def on_ack(connection=nil,subscribe=nil,messages=nil)
      if connection.class.method_defined?(:j_del) && subscribe.class == Hash && messages.class == Array && !block_given?
        @j_del.java_method(:onAck, [Java::IoVertxExtStomp::StompServerConnection.java_class,Java::IoVertxExtStomp::Frame.java_class,Java::JavaUtil::List.java_class]).call(connection.j_del,Java::IoVertxExtStomp::Frame.new(::Vertx::Util::Utils.to_json_object(subscribe)),messages.map { |element| Java::IoVertxExtStomp::Frame.new(::Vertx::Util::Utils.to_json_object(element)) })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling on_ack(#{connection},#{subscribe},#{messages})"
    end

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

Configures the action to execute when messages are acknowledged.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

### - (`self`) on_authentication_request(connection = nil, login = nil, passcode = nil) { ... }

Called when the client connects to a server requiring authentication. It invokes the configured using #auth_provider.

Parameters:

- connection (`::VertxStomp::StompServerConnection`) (defaults to: `nil`) —
  server connection that contains session ID
- login (`String`) (defaults to: `nil`) —
  the login
- passcode (`String`) (defaults to: `nil`) —
  the password

Yields:

- handler receiving the authentication result

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    209
    210
    211
    212
    213
    214
    215
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 209

    def on_authentication_request(connection=nil,login=nil,passcode=nil)
      if connection.class.method_defined?(:j_del) && login.class == String && passcode.class == String && block_given?
        @j_del.java_method(:onAuthenticationRequest, [Java::IoVertxExtStomp::StompServerConnection.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(connection.j_del,login,passcode,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling on_authentication_request(#{connection},#{login},#{passcode})"
    end

### - (`void`) on_close(connection = nil)

This method returns an undefined value.

Called when the connection is closed. This method executes a default behavior and must calls the configured #close_handler if any.

Parameters:

- connection (`::VertxStomp::StompServerConnection`) (defaults to: `nil`) —
  the connection

Raises:

- (`ArgumentError`)

    136
    137
    138
    139
    140
    141
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 136

    def on_close(connection=nil)
      if connection.class.method_defined?(:j_del) && !block_given?
        return @j_del.java_method(:onClose, [Java::IoVertxExtStomp::StompServerConnection.java_class]).call(connection.j_del)
      end
      raise ArgumentError, "Invalid arguments when calling on_close(#{connection})"
    end

### - (`self`) on_nack(connection = nil, subscribe = nil, messages = nil)

Method called by single message (client-individual policy) or a set of message (client policy) are not acknowledged. Not acknowledgment can result from a `NACK` frame or from a timeout (no `ACK` frame received in a given time. Implementations must call the handler configured using #on_nack_handler.

Parameters:

- connection (`::VertxStomp::StompServerConnection`) (defaults to: `nil`) —
  the connection
- subscribe (`Hash`) (defaults to: `nil`) —
  the `SUBSCRIBE` frame
- messages (`Array<Hash>`) (defaults to: `nil`) —
  the acknowledge messages

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

    def on_nack(connection=nil,subscribe=nil,messages=nil)
      if connection.class.method_defined?(:j_del) && subscribe.class == Hash && messages.class == Array && !block_given?
        @j_del.java_method(:onNack, [Java::IoVertxExtStomp::StompServerConnection.java_class,Java::IoVertxExtStomp::Frame.java_class,Java::JavaUtil::List.java_class]).call(connection.j_del,Java::IoVertxExtStomp::Frame.new(::Vertx::Util::Utils.to_json_object(subscribe)),messages.map { |element| Java::IoVertxExtStomp::Frame.new(::Vertx::Util::Utils.to_json_object(element)) })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling on_nack(#{connection},#{subscribe},#{messages})"
    end

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

Configures the action to execute when messages are not acknowledged.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    292
    293
    294
    295
    296
    297
    298
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 292

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

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

Allows customizing the action to do when the server needs to send a `PING` to the client. By default it send a frame containing `EOL` (specification). However, you can customize this and send another frame. However, be aware that this may requires a custom client.

The handler will only be called if the connection supports heartbeats.

Yields:

- the action to execute when a `PING` needs to be sent.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    306
    307
    308
    309
    310
    311
    312
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 306

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

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

Configures a handler that get notified when a STOMP frame is received by the server. This handler can be used for logging, debugging or ad-hoc behavior.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    65
    66
    67
    68
    69
    70
    71
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 65

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

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

Configures the action to execute when a `SEND` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

Configures the action to execute when a `STOMP` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

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

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

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

Configures the action to execute when a `SUBSCRIBE` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    95
    96
    97
    98
    99
    100
    101
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 95

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

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

Configures the action to execute when a `UNSUBSCRIBE` frame is received.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    105
    106
    107
    108
    109
    110
    111
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-stomp/stomp_server_handler.rb', line 105

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