Class: Vertx::NetSocket

Inherits:
Object
  • Object
show all
Includes:
ReadStream, WriteStream
Defined in:
/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb

Overview

Represents a socket-like interface to a TCP connection on either the client or the server side.

Instances of this class are created on the client side by an NetClient when a connection to a server is made, or on the server side by a NetServer when a server accepts a connection.

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

Instance Method Summary (collapse)

Instance Method Details

- (void) close

This method returns an undefined value.

Close the NetSocket

Raises:

  • (ArgumentError)


173
174
175
176
177
178
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 173

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

- (self) close_handler { ... }

Set a handler that will be called when the NetSocket is closed

Yields:

  • the handler

Returns:

  • (self)

Raises:

  • (ArgumentError)


182
183
184
185
186
187
188
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 182

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

- (self) drain_handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


114
115
116
117
118
119
120
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 114

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

- (self) end_handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


74
75
76
77
78
79
80
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 74

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)


40
41
42
43
44
45
46
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 40

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

- (self) handler { ... }

Yields:

Returns:

  • (self)

Raises:

  • (ArgumentError)


49
50
51
52
53
54
55
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 49

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

- (::Vertx::SocketAddress) local_address

@return the local address for this socket

Returns:

Raises:

  • (ArgumentError)


162
163
164
165
166
167
168
169
170
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 162

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

- (self) pause

Returns:

  • (self)

Raises:

  • (ArgumentError)


57
58
59
60
61
62
63
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 57

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

- (::Vertx::SocketAddress) remote_address

@return the remote address for this socket

Returns:

Raises:

  • (ArgumentError)


151
152
153
154
155
156
157
158
159
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 151

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

- (self) resume

Returns:

  • (self)

Raises:

  • (ArgumentError)


65
66
67
68
69
70
71
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 65

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

- (self) send_file(filename = nil) { ... }

Same as #send_file but also takes a handler that will be called when the send has completed or a failure has occurred

Parameters:

  • filename (String) (defaults to: nil)
    file name of the file to send

Yields:

  • handler

Returns:

  • (self)

Raises:

  • (ArgumentError)


139
140
141
142
143
144
145
146
147
148
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 139

def send_file(filename=nil)
  if filename.class == String && !block_given?
    @j_del.java_method(:sendFile, [Java::java.lang.String.java_class]).call(filename)
    return self
  elsif filename.class == String && block_given?
    @j_del.java_method(:sendFile, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(filename,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
    return self
  end
  raise ArgumentError, "Invalid arguments when calling send_file(filename)"
end

- (self) set_write_queue_max_size(maxSize = nil)

Parameters:

  • maxSize (Fixnum) (defaults to: nil)

Returns:

  • (self)

Raises:

  • (ArgumentError)


105
106
107
108
109
110
111
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 105

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

- (true, false) ssl?

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

Returns:

  • (true, false)

Raises:

  • (ArgumentError)


201
202
203
204
205
206
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 201

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

- (self) upgrade_to_ssl { ... }

Upgrade channel to use SSL/TLS. Be aware that for this to work SSL must be configured.

Yields:

  • the handler will be notified when it's upgraded

Returns:

  • (self)

Raises:

  • (ArgumentError)


192
193
194
195
196
197
198
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 192

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

- (self) write(data) - (self) write(str) - (self) write(str, enc)

Write a to the connection, encoded using the encoding enc.

Overloads:

  • - (self) write(data)

    Parameters:

  • - (self) write(str)

    Parameters:

    • str (String)
      the string to write
  • - (self) write(str, enc)

    Parameters:

    • str (String)
      the string to write
    • enc (String)
      the encoding to use

Returns:

  • (self)

Raises:

  • (ArgumentError)


90
91
92
93
94
95
96
97
98
99
100
101
102
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 90

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

- (String) write_handler_id

When a NetSocket 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 connection. This allows you to write data to other connections which are owned by different event loops.

Returns:

  • (String)
    the write handler ID

Raises:

  • (ArgumentError)


128
129
130
131
132
133
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 128

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)


32
33
34
35
36
37
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/net_socket.rb', line 32

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