Serviço de entrada e saída de pacotes. Mais...

Diagrama de Hierarquia para lsp.LspSocket:

Métodos Públicos
InternalPack	receive ()
	Recebe um pacote da fila de entrada. Mais...

void	send (Pack p)
	Insere um pacote na fila de saída. Mais...

Atributos Estáticos Protegidos
static final byte	CONNECT = 0

static final byte	DATA = 1

static final byte	ACK = 2

Funções do Pacote
	LspSocket (int port, int queueSize) throws IOException
	Inicia um LspSocket. Mais...

	LspSocket (int port) throws IOException
	Inicia um LspSocket. Mais...

abstract boolean	isActive ()
	Indica até quando o serviço será executado. Mais...

final void	close ()

final LspConnection	connect (SocketAddress sockAddr, LspParams params, ConnectionTriggers triggers) throws TimeoutException
	Tenta estabelecer conexão com um servidor LSP, reenviando solicitação a cada época, até completar o limite da época. Mais...

void	dgramReceiveConnect (final SocketAddress sockAddr, final ByteBuffer buf)
	Tratamento de um pacote do tipo CONNECT recebido. Mais...

void	dgramReceiveData (final SocketAddress sockAddr, final ByteBuffer buf)
	Tratamento de um pacote do tipo DATA recebido. Mais...

void	dgramReceiveAck (final SocketAddress sockAddr, final ByteBuffer buf)
	Tratamento de um pacote do tipo ACK recebido. Mais...

final void	dgramSendData (final LspConnection conn, final short seqNum, final byte[] payload)

final void	dgramSendData (final InternalPack p)

final void	dgramSendAck (final LspConnection conn, final short seqNum)

final void	dgramSendAck (final InternalPack p)

abstract LspConnection	usedConnection (short connId)
	Obtém o objeto LspConnection em uso. Mais...

int	getPort ()

Funções Estáticas do Pacote
static final byte[]	payload (final ByteBuffer buf)
	Helper para obter um array de bytes com o resto do ByteBuffer. Mais...

Descrição Detalhada

Serviço de entrada e saída de pacotes.

Classe abstrata.

Autor: Wagner Macedo

Definição na linha 26 do arquivo LspSocket.java.

Construtores & Destrutores

lsp.LspSocket.LspSocket	(	int	port,
		int	queueSize
	)		throws IOException

package

Inicia um LspSocket.

Parâmetros

port	Porta onde o socket estará vinculado
queueSize	Tamanho inicial das filas de entrada e saída

Exceções

SocketException

Definição na linha 66 do arquivo LspSocket.java.

                                                           {
         // Cria o socket e as filas
         this.socket = new DatagramSocket(port);
         this.port = this.socket.getLocalPort();
         this.inputQueue = new LinkedBlockingQueue<>(queueSize);
         this.outputQueue = new LinkedBlockingDeque<>(queueSize);
 
         // Inicializa thread de entradas
         this.inputThread = new Thread(new InputTask());
         this.inputThread.setDaemon(true);
         this.inputThread.start();
 
         // Inicializa thread de saídas
         this.outputThread = new Thread(new OutputTask());
         this.outputThread.setDaemon(true);
         this.outputThread.start();
     }

lsp.LspSocket.LspSocket ( int port ) throws IOException

package

Inicia um LspSocket.

Parâmetros

port	Porta onde o socket estará vinculado

Exceções

SocketException

Definição na linha 90 do arquivo LspSocket.java.

                                            {
         this(port, QUEUE_ZISE);
     }

Métodos

final void lsp.LspSocket.close ( )

package

Definição na linha 102 do arquivo LspSocket.java.

                        {
         socket.close();
 
         // Para todas as threads
         inputThread.interrupt();
         outputThread.interrupt();
 
         // Limpeza de memória
         inputQueue.clear();
         outputQueue.clear();
     }

final LspConnection lsp.LspSocket.connect	(	SocketAddress	sockAddr,
		LspParams	params,
		ConnectionTriggers	triggers
	)		throws TimeoutException

package

Tenta estabelecer conexão com um servidor LSP, reenviando solicitação a cada época, até completar o limite da época.

Definição na linha 118 do arquivo LspSocket.java.

                                                                                                                                {
         // Novo processo de conexão
         final ConnectTask task = new ConnectTask(sockAddr, params);
 
         try {
             while (isActive()) {
                 synchronized (connectLock) {
                     // Se não há um processo de conexão em curso, registra um
                     if (this.connectTask == null) {
                         this.connectTask = task;
                     }
 
                     // Havendo um processo de conexão em curso, aguarda uma
                     // época e tenta se conectar novamente
                     else {
                         Thread.sleep(params.getEpoch());
                         continue;
                     }
                 }
 
                 // Executa o processo de conexão
                 final ExecutorService exec = Executors.newSingleThreadExecutor();
                 final Future<Short> id = exec.submit(task);
 
                 // Se o processo concluir corretamente, uma nova conexão será gerada
                 try {
                     final short connId = id.get();
                     return new LspConnection(connId, sockAddr, params, triggers);
                 }
 
                 // Se uma exceção foi lançada, então relança-a contextualmente
                 catch (ExecutionException e) {
                     if (e.getCause() instanceof TimeoutException) {
                         throw (TimeoutException) e.getCause().fillInStackTrace();
                     } else {
                         throw new RuntimeException(e);
                     }
                 }
 
                 // Garante a liberação da thread de requisição de conexão e
                 // registra que o processo de conexão se encerrou
                 finally {
                     exec.shutdown();
                     this.connectTask = null;
                 }
             }
         } catch (InterruptedException e) {}
 
         return null;
     }

Este é o diagrama das funções utilizadas por esta função:

void lsp.LspSocket.dgramReceiveAck	(	final SocketAddress	sockAddr,
		final ByteBuffer	buf
	)

package

Tratamento de um pacote do tipo ACK recebido.

Definição na linha 228 do arquivo LspSocket.java.

                                                                              {
         final short connId = buf.getShort();
         final LspConnection conn = usedConnection(sockAddr, connId);
 
         // Se o connId é válido, reconhece a mensagem
         if (conn != null) {
             final short seqNum = buf.getShort();
             conn.ack(seqNum);
         }
 
         // Senão verifica se há uma tentativa de conexão em curso. Caso
         // positivo, verifica também se id não é 0, número de sequência é 0,
         // conferindo antes se o ACK vem do socket remoto correto
         else {
             final ConnectTask task = connectTask;
             if (task != null && connId > 0 && buf.getShort() == 0
                     && sockAddr.equals(task.sockAddr)) {
                 task.ack(connId);
             }
         }
     }

Este é o diagrama das funções utilizadas por esta função:

void lsp.LspSocket.dgramReceiveConnect	(	final SocketAddress	sockAddr,
		final ByteBuffer	buf
	)

package

Tratamento de um pacote do tipo CONNECT recebido.

Esse método deve ser sobrescrito pelo servidor

Definição na linha 199 do arquivo LspSocket.java.

199 {

200 }

void lsp.LspSocket.dgramReceiveData	(	final SocketAddress	sockAddr,
		final ByteBuffer	buf
	)

package

Tratamento de um pacote do tipo DATA recebido.

Definição na linha 203 do arquivo LspSocket.java.

                                                                               {
         LspConnection conn = usedConnection(sockAddr, buf.getShort());
 
         // Só continua se a conexão é válida e não estiver fechada
         if (conn != null && !conn.isClosed()) {
             short seqNum = buf.getShort();
             byte[] payload = payload(buf);
             InternalPack pack = new InternalPack(conn, seqNum, payload);
 
             // Se a mensagem foi enfileirada, envia o ACK e informa o número
             // de sequência à conexão (usado nos disparos da época).
             if (inputQueue.offer(pack)) {
                 dgramSendAck(pack);
                 conn.received(seqNum);
             }
 
             // Caso contrário, mesmo que a mensagem não possa ser lida,
             // atualiza o momento da última mensagem recebida
             else {
                 conn.received();
             }
         }
     }

Este é o diagrama das funções utilizadas por esta função:

final void lsp.LspSocket.dgramSendAck	(	final LspConnection	conn,
		final short	seqNum
	)

package

Definição na linha 283 do arquivo LspSocket.java.

                                                                           {
         dgramSend(ACK, conn, seqNum, PAYLOAD_NIL);
     }

Este é o diagrama das funções que utilizam esta função:

final void lsp.LspSocket.dgramSendAck ( final InternalPack p )

package

Definição na linha 287 do arquivo LspSocket.java.

                                                   {
         dgramSendAck(p.getConnection(), p.getSeqNum());
     }

Este é o diagrama das funções utilizadas por esta função:

final void lsp.LspSocket.dgramSendData	(	final LspConnection	conn,
		final short	seqNum,
		final byte[]	payload
	)

package

Definição na linha 271 do arquivo LspSocket.java.

                                                                                                  {
         if (payload.length > LEN_PAYLOAD) {
             throw new IllegalArgumentException("Payload não pode ser maior que " + LEN_PAYLOAD);
         }
 
         dgramSend(DATA, conn, seqNum, payload);
     }

Este é o diagrama das funções que utilizam esta função:

final void lsp.LspSocket.dgramSendData ( final InternalPack p )

package

Definição na linha 279 do arquivo LspSocket.java.

                                                    {
         dgramSendData(p.getConnection(), p.getSeqNum(), p.getPayload());
     }

Este é o diagrama das funções utilizadas por esta função:

int lsp.LspSocket.getPort ( )

package

Definição na linha 349 do arquivo LspSocket.java.

                   {
         return this.port;
     }

abstract boolean lsp.LspSocket.isActive ( )

packagepure virtual

Indica até quando o serviço será executado.

Esse método deve ser implementado em uma subclasse.

Retorna: false para parar o serviço

Este é o diagrama das funções que utilizam esta função:

static final byte [] lsp.LspSocket.payload ( final ByteBuffer buf )

staticpackage

Helper para obter um array de bytes com o resto do ByteBuffer.

Definição na linha 292 do arquivo LspSocket.java.

                                                       {
         byte[] bs = new byte[buf.remaining()];
         for (int i = 0; i < bs.length; i++) {
             bs[i] = buf.get();
         }
 
         return bs;
     }

Este é o diagrama das funções que utilizam esta função:

InternalPack lsp.LspSocket.receive ( )

Recebe um pacote da fila de entrada.

Definição na linha 323 do arquivo LspSocket.java.

                                   {
         while (isActive()) {
             try {
                 InternalPack nextPack = inputQueue.poll(1, TimeUnit.SECONDS);
                 if (nextPack != null) {
                     return nextPack;
                 }
             } catch (InterruptedException e) {
                 break;
             }
         }
 
         return null;
     }

Este é o diagrama das funções utilizadas por esta função:

void lsp.LspSocket.send ( Pack p )

Insere um pacote na fila de saída.

Definição na linha 339 do arquivo LspSocket.java.

                              {
         if (p.getPayload().length > LEN_PAYLOAD) {
             throw new IllegalArgumentException("Payload não pode ser maior que " + LEN_PAYLOAD);
         }
 
         if (!outputQueue.offer(p)) {
             throw new IllegalStateException("Fila de saída cheia");
         }
     }

Este é o diagrama das funções utilizadas por esta função:

abstract LspConnection lsp.LspSocket.usedConnection ( short connId )

packagepure virtual

Obtém o objeto LspConnection em uso.

Parâmetros

connId Id de conexão para validar/pesquisar

Retorna: Uma instância de LspConnection ou null

Este é o diagrama das funções que utilizam esta função:

Atributos

final byte lsp.LspSocket.ACK = 2

staticprotected

Definição na linha 29 do arquivo LspSocket.java.

final byte lsp.LspSocket.CONNECT = 0

staticprotected

Definição na linha 27 do arquivo LspSocket.java.

final byte lsp.LspSocket.DATA = 1

staticprotected

Definição na linha 28 do arquivo LspSocket.java.

A documentação para esta classe foi gerada a partir do seguinte arquivo:

src/lsp/LspSocket.java

Métodos Públicos

Atributos Estáticos Protegidos

Funções do Pacote

Funções Estáticas do Pacote

Descrição Detalhada

Construtores & Destrutores

Métodos

Atributos