Class: VertxWeb::SockJSSocket

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

Overview

You interact with SockJS clients through instances of SockJS socket.

The API is very similar to Vertx::WebSocket. It implements both and so it can be used with Vertx::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)


33
34
35
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 33

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

+ (Object) j_api_type



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

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class



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

def self.j_class
  Java::IoVertxExtWebHandlerSockjs::SockJSSocket.java_class
end

+ (Object) unwrap(obj)



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

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

+ (Object) wrap(obj)



36
37
38
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 36

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

Instance Method Details

- (void) close(statusCode = nil, reason = nil)

This method returns an undefined value.

Close it giving a status code and reason. Only Applicable to RawWebSocket will downgrade to plain close for other transports.

Parameters:

  • statusCode (Fixnum) (defaults to: nil)
  • reason (String) (defaults to: nil)

Raises:

  • (ArgumentError)


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

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

- (self) drain_handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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

- (void) end(t = nil)

This method returns an undefined value.

Same as #end but writes some data to the stream before ending.

Parameters:

Raises:

  • (ArgumentError)


51
52
53
54
55
56
57
58
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 51

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

- (self) end_handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


142
143
144
145
146
147
148
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 142

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

- (self) exception_handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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

- (self) fetch(amount = nil)

Fetch the specified amount of elements. If the ReadStream has been paused, reading will recommence with the specified amount of items, otherwise the specified amount will be added to the current stream demand.

Parameters:

  • amount (Fixnum) (defaults to: nil)

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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

- (self) handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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 corresponding to the last request for this socket or the websocket handshake Any cookie headers will be removed for security reasons

Returns:

Raises:

  • (ArgumentError)


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

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

- (::Vertx::SocketAddress) local_address

Return the local address for this socket

Returns:

Raises:

  • (ArgumentError)


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

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

- (self) pause

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-web/sock_js_socket.rb', line 125

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:

Raises:

  • (ArgumentError)


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

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:

Yields:

Raises:

  • (ArgumentError)


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

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

- (::Vertx::SocketAddress) remote_address

Return the remote address for this socket

Returns:

Raises:

  • (ArgumentError)


211
212
213
214
215
216
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 211

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

- (self) resume

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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

- (self) set_write_queue_max_size(maxSize = nil)

Parameters:

  • maxSize (Fixnum) (defaults to: nil)

Returns:

  • (self)

Raises:

  • (ArgumentError)


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

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

- (String) uri

Return the URI corresponding to the last request for this socket or the websocket handshake

Returns:

  • (String)

Raises:

  • (ArgumentError)


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

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

- (::VertxWeb::Session) web_session

Returns the Vert.x-Web session corresponding to this socket

Returns:

Raises:

  • (ArgumentError)


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

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

- (::VertxAuthCommon::User) web_user

Returns the Vert.x-Web user corresponding to this socket

Returns:

Raises:

  • (ArgumentError)


250
251
252
253
254
255
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 250

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

- (self) write(data) - (self) write(data)

Write a String to the socket, encoded in UTF-8.

Overloads:

  • - (self) write(data)

    Parameters:

  • - (self) write(data)

    Parameters:

    • data (String)
      the string to write

Returns:

  • (self)

Raises:

  • (ArgumentError)


155
156
157
158
159
160
161
162
163
164
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 155

def write(param_1=nil)
  if param_1.class.method_defined?(:j_del) && !block_given?
    @j_del.java_method(:write, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(param_1.j_del)
    return self
  elsif param_1.class == String && !block_given?
    @j_del.java_method(:write, [Java::java.lang.String.java_class]).call(param_1)
    return self
  end
  raise ArgumentError, "Invalid arguments when calling write(#{param_1})"
end

- (String) write_handler_id

When a SockJSSocket is created it automatically registers an event handler with the event bus, the ID of that handler is given by writeHandlerID.

Given this ID, a different event loop can send a buffer to that event handler using the event bus and that buffer will be received by this instance in its own event loop and written to the underlying socket. This allows you to write data to other sockets which are owned by different event loops.

Returns:

  • (String)

Raises:

  • (ArgumentError)


190
191
192
193
194
195
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 190

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

- (true, false) write_queue_full?

This will return true if there are more bytes in the write queue than the value set using #set_write_queue_max_size

Returns:

  • (true, false)
    true if write queue is full

Raises:

  • (ArgumentError)


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

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