me.melchor9000.net

Class Socket

java.lang.Object

me.melchor9000.net.Socket

All Implemented Interfaces:

java.lang.AutoCloseable

Direct Known Subclasses:

TCPSocket, UDPSocket

public abstract class Socket
extends java.lang.Object
implements java.lang.AutoCloseable

A Socket from any protocol which has the basic read and write operations.

Field Summary

Fields

Modifier and Type	Field and Description
protected io.netty.bootstrap.Bootstrap	bootstrap
protected long	bytesRead
protected long	bytesWrote
protected io.netty.channel.Channel	channel
protected IOService	service

Method Summary

Modifier and Type	Method and Description
void	addOnDataReceivedListener(Callback<Socket> cbk) Adds a Callback that will be called every time some data is available to read.
void	bind() Binds the socket to any port in the default interface without connecting to some remote endpoint.
void	bind(java.net.SocketAddress local) Binds the socket to a local address.
protected void	checkSocketCreated(java.lang.String method) Call this method to check if the socket is created, if it's not, then throws a SocketNotCreated exception.
void	close() Closes the socket after the current operation is done.
Future<java.lang.Void>	closeAsync() Closes the socket after the current operation is done, and then calls cbk with the result, either successful or failure.
void	connect(java.net.InetAddress address, int port) Binds the socket to a random port and connects to the remote endpoint as address and port.
void	connect(java.net.SocketAddress endpoint) Binds the socket to a random port and connects to the remote endpoint.
void	connect(java.lang.String hostName, int port, DNSServerProvider provider) Binds the socket to a random port and connects to the remote endpoint as hostName and port.
Future<java.lang.Void>	connectAsync(java.net.InetAddress address, int port) Binds the socket to a random port and connects to the remote endpoint as address and port.
Future<java.lang.Void>	connectAsync(java.net.SocketAddress endpoint) Binds the socket to a random port and connects to the remote endpoint asynchronously.
Future<java.lang.Void>	connectAsync(java.lang.String hostName, int port, DNSServerProvider provider) Binds the socket to a random port and connects to the remote endpoint as hostName and port.
protected <ReturnType> Future<ReturnType>	createFuture(io.netty.util.concurrent.Future<ReturnType> n)
protected <ReturnType> FutureImpl<ReturnType>	createFuture(Procedure whenCancelled)
protected void	fireReceivedData() Calls all methods that want to be notified when some data have been received.
boolean	isOpen()
java.net.SocketAddress	localEndpoint() Gets the SocketAddress of the local socket, or returns null if the socket is not created yet using one of the connect or bind methods.
long	receive(io.netty.buffer.ByteBuf data) Receives some data from the socket into the ByteBuf.
abstract long	receive(io.netty.buffer.ByteBuf data, int bytes) Receives some data from the socket and writes it into the ByteBuf data a maximum of bytes bytes.
Future<java.lang.Long>	receiveAsync(io.netty.buffer.ByteBuf data) Receives some data from the socket into the ByteBuf.
abstract Future<java.lang.Long>	receiveAsync(io.netty.buffer.ByteBuf data, int bytes) Receives some data from the socket and writes it into the ByteBuf data a maximum of bytes bytes.
long	receivedBytes()
java.net.SocketAddress	remoteEndpoint() Gets the SocketAddress of the remote endpoint if this socket is connected to one.
long	send(io.netty.buffer.ByteBuf data) Sends some data stored in the ByteBuf data, starting from its current position with a size of data.remaining() bytes.
long	send(io.netty.buffer.ByteBuf data, int bytes) Sends some data stored in the ByteBuf data, starting from its current position with a size of bytes.
long	send(java.lang.String data) Sends the contents of the String using the default platform Charset, without any extra characters.
Future<java.lang.Void>	sendAsync(io.netty.buffer.ByteBuf data) Sends some data stored in the ByteBuf data, with the remaining bytes of it.
Future<java.lang.Void>	sendAsync(io.netty.buffer.ByteBuf data, int bytes) Sends some data stored in the ByteBuf data, starting from its current position with a size of bytes.
Future<java.lang.Void>	sendAsync(java.lang.String data) Sends the contents of the String using the default platform Charset, without any extra characters.
long	sendBytes()
<T> boolean	setOption(io.netty.channel.ChannelOption<T> type, T value) Changes an option of this socket with a new value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

service

protected final IOService service

channel

protected io.netty.channel.Channel channel

bootstrap

protected io.netty.bootstrap.Bootstrap bootstrap

bytesRead

protected long bytesRead

bytesWrote

protected long bytesWrote

Method Detail

close

public void close()

Closes the socket after the current operation is done. It can throw an Throwable if an error occurs. This operation blocks the thread.

Specified by:

close in interface java.lang.AutoCloseable

closeAsync

@NotNull
public Future<java.lang.Void> closeAsync()

Closes the socket after the current operation is done, and then calls cbk with the result, either successful or failure.

Returns:

Future about the task

bind

public void bind(@NotNull
                 java.net.SocketAddress local)

Binds the socket to a local address. Depending on the implementation, this could fail.

Parameters:

local - address to bind

bind

public void bind()

Binds the socket to any port in the default interface without connecting to some remote endpoint. Depending on the implementation, this could fail.

connect

public void connect(@NotNull
                    java.net.SocketAddress endpoint)
             throws java.lang.InterruptedException

Binds the socket to a random port and connects to the remote endpoint.

Parameters:

endpoint - remote endpoint

Throws:

java.lang.InterruptedException - When this Thread is interrupted

connectAsync

@NotNull
public Future<java.lang.Void> connectAsync(@NotNull
                                                    java.net.SocketAddress endpoint)

Binds the socket to a random port and connects to the remote endpoint asynchronously. Returns a Future where the task can be managed.

Parameters:

endpoint - remote endpoint to connect

Returns:

Future of the task

connect

public void connect(@NotNull
                    java.net.InetAddress address,
                    int port)
             throws java.lang.InterruptedException

Binds the socket to a random port and connects to the remote endpoint as address and port.

Parameters:

address - address of the remote endpoint

port - port of the remote endpoint

Throws:

java.lang.InterruptedException - When this Thread is interrupted while waiting to connect

connect

public void connect(@NotNull
                    java.lang.String hostName,
                    int port,
                    @NotNull
                    DNSServerProvider provider)
             throws java.net.UnknownHostException,
                    java.lang.InterruptedException

Binds the socket to a random port and connects to the remote endpoint as hostName and port.

Parameters:

hostName - domain of the remote endpoint

port - port of the remote endpoint

provider - A DNSServerProvider implementation

Throws:

java.lang.InterruptedException - When this Thread is interrupted while waiting to connect

java.net.UnknownHostException - If the hostName cannot be resolved

connectAsync

@NotNull
public Future<java.lang.Void> connectAsync(@NotNull
                                                    java.net.InetAddress address,
                                                    int port)

Binds the socket to a random port and connects to the remote endpoint as address and port.

Parameters:

address - address of the remote endpoint

port - port of the remote endpoint

Returns:

Future of the task

connectAsync

@NotNull
public Future<java.lang.Void> connectAsync(@NotNull
                                                    java.lang.String hostName,
                                                    int port,
                                                    @NotNull
                                                    DNSServerProvider provider)
                                             throws java.net.UnknownHostException

Binds the socket to a random port and connects to the remote endpoint as hostName and port.

Parameters:

hostName - domain of the remote endpoint

port - port of the remote endpoint

provider - A DNSServerProvider implementation

Returns:

Future of the task

Throws:

java.net.UnknownHostException - If the hostName cannot be resolved

receive

public abstract long receive(io.netty.buffer.ByteBuf data,
                             int bytes)
                      throws java.lang.Throwable

Receives some data from the socket and writes it into the ByteBuf data a maximum of bytes bytes. This method don't read exactly bytes bytes, only at most. To ensure read all the bytes, use one of the SocketUtil methods.

Parameters:

data - buffer where to write on all the data

bytes - maximum number of bytes to read

Returns:

number of bytes read currently

Throws:

java.lang.Throwable - if the receive operation fails, throws something

receiveAsync

@NotNull
public abstract Future<java.lang.Long> receiveAsync(io.netty.buffer.ByteBuf data,
                                                             int bytes)

Receives some data from the socket and writes it into the ByteBuf data a maximum of bytes bytes. This method don't read exactly bytes bytes, only at most. To ensure read all the bytes, use one of the SocketUtil methods. This operation is done asynchronously, so returns a Future for the task.

Parameters:

data - buffer where to write on all the data

bytes - maximum number of bytes to read

Returns:

a Future representing this task

send

public long send(@NotNull
                 io.netty.buffer.ByteBuf data,
                 int bytes)
          throws java.lang.InterruptedException

Sends some data stored in the ByteBuf data, starting from its current position with a size of bytes. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent.

Parameters:

data - buffer with the data to be sent

bytes - number of bytes to send

Returns:

bytes sent

Throws:

java.lang.InterruptedException - If there's an interruption while sending the data

sendAsync

@NotNull
public Future<java.lang.Void> sendAsync(io.netty.buffer.ByteBuf data,
                                                 int bytes)

Sends some data stored in the ByteBuf data, starting from its current position with a size of bytes. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent. This is an asynchronous operation, so returns a Future representing the task.

Parameters:

data - buffer with the data to be sent

bytes - number of bytes to send

Returns:

a Future representing this task

sendAsync

@NotNull
public Future<java.lang.Void> sendAsync(@NotNull
                                                 io.netty.buffer.ByteBuf data)

Sends some data stored in the ByteBuf data, with the remaining bytes of it. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent. This is an asynchronous operation, so returns a Future representing the task.

Parameters:

data - buffer with the data to be sent

Returns:

a Future representing this task

receive

public long receive(@NotNull
                    io.netty.buffer.ByteBuf data)
             throws java.lang.Throwable

Receives some data from the socket into the ByteBuf. This method doesn't ensure to write exactly data.remaining() bytes. Use instead SocketUtil methods.

Parameters:

data - ByteBuf where to write the data

Returns:

number of bytes read

Throws:

java.lang.Throwable - If something bad happens while receiving the data

receiveAsync

@NotNull
public Future<java.lang.Long> receiveAsync(@NotNull
                                                    io.netty.buffer.ByteBuf data)

Receives some data from the socket into the ByteBuf. This method doesn't ensure to write exactly data.remaining() bytes. Use instead SocketUtil methods. This is an asynchronous operation, so it returns a Future about this task.

Parameters:

data - ByteBuf where to write the data

Returns:

a Future representing the task

send

public long send(@NotNull
                 io.netty.buffer.ByteBuf data)
          throws java.lang.InterruptedException

Sends some data stored in the ByteBuf data, starting from its current position with a size of data.remaining() bytes. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent.

Parameters:

data - ByteBuf with the data to be send

Returns:

bytes sent

Throws:

java.lang.InterruptedException - if the send operation is interrupted

sendAsync

@NotNull
public Future<java.lang.Void> sendAsync(@NotNull
                                                 java.lang.String data)

Sends the contents of the String using the default platform Charset, without any extra characters. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent. That is an asynchronous operation, so it returns a Future about this task.

Parameters:

data - the String to send

Returns:

a Future representing the task

send

public long send(@NotNull
                 java.lang.String data)
          throws java.lang.InterruptedException

Sends the contents of the String using the default platform Charset, without any extra characters. Depending on the implementation and its options, is possible that the data could not be sent in the moment, or only a portion of it is sent.

Parameters:

data - the String to send

Returns:

number of bytes sent

Throws:

java.lang.InterruptedException - if the send operation is interrupted

setOption

public <T> boolean setOption(@NotNull
                             io.netty.channel.ChannelOption<T> type,
                             @NotNull
                             T value)

Changes an option of this socket with a new value. Returns true if the option is changed.

Type Parameters:

T - Type of the new value for the option

Parameters:

type - Option to change

value - New value

Returns:

true if the option was set

See Also:

ChannelOption

remoteEndpoint

public java.net.SocketAddress remoteEndpoint()

Gets the SocketAddress of the remote endpoint if this socket is connected to one.

Returns:

remote endpoint or null if not connected

localEndpoint

public java.net.SocketAddress localEndpoint()

Gets the SocketAddress of the local socket, or returns null if the socket is not created yet using one of the connect or bind methods.

Returns:

local endpoint

isOpen

public boolean isOpen()

Returns:

true if the socket is open, false if it's closed

sendBytes

public long sendBytes()

Returns:

the number of bytes sent by this socket

receivedBytes

public long receivedBytes()

Returns:

the number of bytes received by this socket

addOnDataReceivedListener

public void addOnDataReceivedListener(Callback<Socket> cbk)

Adds a Callback that will be called every time some data is available to read. A receive operation called inside one of this callbacks, will be added at the end of the read operation queue. If there wasn't any receive operations before this one, a receive call will not block and will return all possible data.

Parameters:

cbk - listener for when some data is received

fireReceivedData

protected void fireReceivedData()
                         throws java.lang.Exception

Calls all methods that want to be notified when some data have been received. Implementors must call always this method when some data have been received.

Throws:

java.lang.Exception - some error

checkSocketCreated

protected void checkSocketCreated(java.lang.String method)

Call this method to check if the socket is created, if it's not, then throws a SocketNotCreated exception.

Parameters:

method - method that was called

createFuture

protected <ReturnType> FutureImpl<ReturnType> createFuture(Procedure whenCancelled)

createFuture

protected <ReturnType> Future<ReturnType> createFuture(io.netty.util.concurrent.Future<ReturnType> n)