Atividades Práticas Supervisionadas

Campus: Swift 2019

D322FA9 - JOÃO VICTOR DUTRA SANTOS

N1918C9 - LUCAS RAMALHO CAMAROTTO
 Índice

F P
Fundamentos da comunicação de dados em rede Plano de desenvolvimento da aplicação 12
(conceitos gerais) 7 Projeto(estrutura) do programa 18
I R
Introdução 5 Relatório com linhas de código 19
O
Objetivo do trabalho 4
Objetivo do trabalho

O objetivo desse trabalho é desenvolver uma aplicação de comunicação

com envio de arquivos, histórico, uso de emoticons e interface web a fim de colocar
em práticas os conceitos aprendidos nesse semestre na disciplina de Redes de
Computadores. A proposta é criar uma aplicação que permita que duas ou mais
pessoas possam se comunicar em uma rede, utilizando o protocolo TCP/IP.
A base para o problema do trabalho é uma necessidade fictícia de um órgão
estatal, isto é, a Secretaria de Estado do Meio Ambiente tem a intenção de saber
quais atividades industriais estão gerando poluição do Rio Tietê desde sua nascente
em Salesópolis (SP) até a sua passagem pela região da grande São Paulo. Para
isso deverá haver troca de informações entre a equipe de inspetores e a Secretaria
do Meio Ambiente.
Introdução

A indústria da informática teve um progresso espetacular em um curto

período de tempo e as redes de computadores também fazem parte desse
crescimento. Hoje, com um simples clique de um botão, as organizações, com suas
filiais espalhadas pelo mundo, podem comunicar-se e obter informações sobre
desempenho, relatórios de produção, estoque e clientes, independente da sua
localização.
Durante a primeira década dos sistemas computacionais, os computadores
eram altamente centralizados, as empresas e universidades possuíam apenas um
ou dois computadores
e as grandes instituições algumas dezenas. Todos eles eram isolados, não
existia nenhuma comunicação entre eles. Com o avanço da comunicação, a forma
com que os sistemas computacionais operavam foi totalmente modificada, a visão
que os usuários tinham sobre os grandes centros de computação, em que os
trabalhos eram levados para serem processados, tornou-se obsoleta, sendo
substituídos pelas redes de computadores. Agora, os trabalhos são processados por
um grande número de computadores separados fisicamente e totalmente
interligados.
Em termos práticos, uma rede de computador é formada por dois ou mais
computadores interligados, podendo existir uma troca de informação entre eles.
Essa ligação não precisa ser feita obrigatoriamente através de um fio, pois existem
diversas tecnologias que permitem a troca de dados, como infravermelho,
micro-ondas, satélite etc.
Com o problema da comunicação apresentado na seção Objetivos em
mente, optamos por uma abordagem que permitisse que a equipe de inspetores
conseguisse conversar entre si e mantivesse um histórico que poderia servir para o
órgão que deveria ter acesso aos dados.
A aplicação teria de ser desenvolvida pensando em o tripé servidor, cliente e
banco de dados para manter o histórico da troca de mensagens. Para nosso
problema proposto a solução passa por manter um registro das atividades. Optamos
por um misto de modelo relacional e não relacional para o banco de dados. Os
dados de cadastro ficam armazenados em SQL e os demais dados que fogem ao
padrão de cadastro (emojis, imagens em geral, documentos binários como planilhas
e arquivos diversos, além do histórico da conversa ficam a cargo do MongoDB). No
caso do servidor e do cliente, usamos Jsons para facilitar a leitura e produção do
código da aplicação usando linguagem Java em conjunto com front-end com estilo
web.
Fundamentos da comunicação de dados em rede (conceitos gerais)

Comunicação de dados

Comunicação de dados é a troca de informação entre dois dispositivos

através de algum meio de comunicação como, por exemplo, um par de fios.

Um sistema básico de comunicação de dados é composto por cinco

elementos:

a) Mensagem: é a informação a ser transmitida. Pode ser constituída de texto,

números, figuras, áudio e vídeo – ou qualquer combinação desses
elementos;

b) Transmissor: é o dispositivo que envia a mensagem de dados. Pode ser um

computador, uma estação de trabalho, um telefone, uma câmera de vídeo,
entre outros;

c) Receptor: é o dispositivo que recebe a mensagem. Pode ser um

computador, uma estação de trabalho, um telefone, uma câmera de vídeo,
etc.;

d) Meio: é o caminho físico por onde viaja uma mensagem dirigida ao receptor;

e) Protocolo: é um conjunto de regras que governa a comunicação de dados.

Ele representa um acordo entre os dispositivos que se comunicam.
TOPOLOGIAS DE REDES
As redes de computadores de modo geral estão presentes em nosso
dia-a-dia, estamos tão acostumados a utilizá-las que não nos damos conta da
sofisticação e complexidade da estrutura, que mantém os dados e as informações
ao nosso redor.
A maneira com que as redes de computadores são interligadas é um ponto
importante, pois dispositivos podem ser interconectados de várias formas
envolvendo tanto o ponto
de vista físico, como o lógico. A topologia física refere-se ao layout físico e
ao meio de conexão dos dispositivos de redes, ou seja, como eles são conectados, e
esses dispositivos que formam a estrutura de uma rede são chamados de nós ou
nodos. A topologia lógica é a forma com que os nós se comunicam através dos
meios de transmissão.
As redes são compostas por arranjos topológicos interligados, cuja principal
finalidade, a economia de recursos, pois com suas estruturas o compartilhamento e
o processamento individual são distribuídos para todos, o que torna as informações
ao alcance de todos os usuários que estão conectados.

TIPOS DE TRANSMISSÃO
Sinais Elétricos
Os sinais elétricos são tensões que variam ao longo do tempo, sendo que
algumas delas são úteis, pois transmitem alguns tipos de dados, como os que
trafegam nas redes de computadores.
Essas tensões podem ser classificadas como sinais analógicos e digitais.
Sinais Digitais
A grande maioria dos sinais elétricos utilizados na computação são digitais,
e os que são analógicos são digitalizados para que depois sejam processados e
armazenados.
Os sinais digitais assumem uma infinidade de valores, mas não são
matematicamente perfeitos, por isso eles não representam apenas dois valores 0 e
1, como alguns textos ensinam. Como exemplo, em uma transmissão de uma
sequência de bits 0110111001 são usadas as tensões de + 12 volts e – 12 volts para
representar os bits 0 e 1, só que elas não assumem valores exatos, acontecendo
oscilações e em vez de + 12 volts , temos + 11,3 volts ou 12,20 volts. Além dessas
oscilações, o sinal pode sofrer ruídos e interferências, problema que não prejudica a
qualidade do sinal se o valor não for muito acentuado.

MEIOS FÍSICOS DE TRANSMISSÃO

Os meios físicos de transmissão são compostos pelos cabos coaxiais, par
trançado, fibra óptica, transmissão a rádio, transmissão via satélite e são divididos
em duas categorias: os meios guiados e os meios não guiados.
No meio guiado, o sinal percorre através de meios sólidos, como a fibra, o
cabo coaxial e o par trançado. No meio não guiado, o sinal propaga-se na atmosfera,
como é o caso das redes sem fi o e transmissões via rádio e via satélite.

O modelo OSI
Para facilitar a interconexão de sistemas de computadores, a ISO
(International Standards Organization) desenvolveu um modelo de referência
chamado OSI (Open Systems Interconnection), para que fabricantes pudessem criar
protocolos a partir desse modelo.
Camadas do modelo OSI
O modelo de referência OSI é o método para descrever como os conjuntos
interconectados de hardware e software de rede podem ser organizados para que
trabalhem concomitantemente no mundo das redes. Com efeito, o modelo OSI
oferece um modo de dividir arbitrariamente a tarefa da rede em pedaços separados,
que estão sujeitos ao processo formal de padronização.
Para fazer isso, o modelo de referência OSI descreve sete camadas de
funções de rede, conforme podemos ver na figura abaixo:
Camada Descrição
Esta camada pega os quadros enviados pela camada de enlace e
Físico os transforma em sinais compatíveis com o meio por onde os
dados deverão ser transmitidos
A camada de enlace pega os pacotes de dados recebidos da
camada de rede e os transforma em quadros que trafegarão pela
Enlace de rede, adicionando informações como o endereço da placa de rede
Dados de origem, o endereço da placa de rede de destino, os dados de
controle, os dados em si e a checagem de redundância cíclica
(CRC).
É responsável pelo endereçamento dos pacotes, convertendo
Rede endereços lógicos em endereços físicos, de forma que os pacotes
consigam chegar corretamente ao destino.
Esta camada é responsável por pegar os dados enviados pela
Transporte camada de sessão e dividi-los em pacotes que serão transmitidos
à camada de rede.
A camada de sessão permite que duas aplicações em
Sessão computadores diferentes estabeleçam uma sessão de
comunicação.
A camada de apresentação converte o formato do dado recebido
Apresentaçã
pela camada de aplicação em um formato comum a ser usado na
o
transmissão desse dado
 A camada de aplicação faz a interface entre o protocolo de
Aplicação comunicação e o aplicativo que pediu ou receberá a informação
através da rede

O modelo TCP/IP
O modelo de referência mais conhecido é o TCP/IP (Transmisson Control
Protocol / Internet Protocol). O modelo TCP/IP foi projetado em quatro camadas

Camada Descrição
Esta camada, de acesso à rede, é a primeira do modelo TCP/IP, sua
Camada função é dar suporte à camada de rede, através dos serviços de acesso
físico e lógico ao meio físico
O nível inter-rede (Internet) é o responsável pelo envio dos datagramas
Inter-rede
de um computador qualquer para o outro computador, independente de
(Internet)
suas localizações na rede.
A camada de transporte é responsável por prover suporte à camada de
Transporte aplicação de maneira confiável (ou não), independente dos serviços
oferecidos pelas camadas de interface de rede e inter-rede.
A quarta camada do modelo TCP/IP é denominada de camada de
Aplicação aplicação. Nesta camada, estão os protocolos que dão suporte às
aplicações dos usuários.
Protocolo de comunicação de dados
Protocolo é a “linguagem” usada pelos dispositivos de uma rede de modo
que eles consigam se entender, isto é, trocar informações entre si. Um protocolo é
um conjunto de regras que governa a comunicação de dados
Exemplos de protocolos são: HTTP – Hyper Text Transfer Protocol; SMTP –
Simple Mail Transfer Protocol; FTP – File Transfer; SNMP – Simple NetWork
Management Protocol; DNS – Domain Name Server; TCP – Transmission Control
Protocol; UDP – User Datagram Protocol e IP – Internet Protocol
Plano de desenvolvimento da aplicação

A tarefa de se produzir uma aplicação que deveria servir como ferramenta de

comunicação entre duas ou mais pessoas (através da pilha de protocolos TCP/IP)
traz, devido à infinidade de maneiras que se pode implementar tal ferramenta, um
desafio em relação a escala do projeto e quais ferramentas deveriam ser utilizadas.
Optamos por usar JAVA conforme a orientação na proposta de trabalho ao invés de
C#, que apesar de usar métodos e classes como JAVA o grupo não tinha
familiaridade com a linguagem.

JSON

Em conjunto com o Java usamos JSON, que é basicamente um formato leve de

troca de informações/dados entre sistemas. Vantagens do JSON: leitura mais
simples; analisador (parsing) mais fácil; JSON suporta objetos; velocidade maior na
execução e transporte de dados; arquivo com tamanho reduzido. A fim de permitir
que diferentes partes da estrutura do projeto conversassem entre si optamos por
usar Json como uma ferramenta em comum, tanto na parte Web, como na parte
cliente, como na parte de servidor, como em conjunto com o Mongo. Isso nos
poupou tempo e permitiu um código mais enxuto e com visual mais limpo, de fácil
leitura.
JSON está constituído em duas estruturas:
Uma coleção de pares nome/valor. Em várias linguagens, isto é caracterizado como
um object, record, struct, dicionário, hash table, keyed list, ou arrays associativas.
Uma lista ordenada de valores. Na maioria das linguagens, isto é caracterizado
como uma array, vetor, lista ou sequência. Estas são estruturas de dados universais.
Virtualmente todas as linguagens de programação modernas as suportam, de uma
forma ou de outra. É aceitável que um formato de troca de dados que seja
independente de linguagem de programação se baseie nestas estruturas.
Em JSON, os dados são apresentados desta forma:
Um objeto é um conjunto desordenado de pares nome/valor. Um objeto começa com
{ (chave de abertura) e termina com } (chave de fechamento). Cada nome é seguido
por : (dois pontos) e os pares nome/valor são seguidos por , (vírgula).

Uma array é uma coleção de valores ordenados. O array começa com [ (conchete de
abertura) e termina com ] (conchete de fechamento). Os valores são separados por ,
(vírgula).

Um valor (value) pode ser uma cadeia de caracteres (string), ou um número, ou true
ou false, ou null, ou um objeto ou uma array. Estas estruturas podem estar
aninhadas.
Uma string é uma coleção de nenhum ou mais caracteres Unicode, envolvido entre
aspas duplas usando barras invertidas como caracter de escape. Um caracter está
representando como um simples caracter de string. Uma cadeia de caracteres é
parecida com uma cadeia de caracteres em C ou Java.

Um número é similar a um número em C ou Java, exceto quando não se usa os

números octais ou hexadecimais.
Espaços em branco podem ser inseridos em qualquer parte dos símbolos. Exceto
pequenos detalhes de codificação, a linguagem é completamente descrita.
Foi necessário o uso do GitHub para controle de versão e também para que todos os
envolvidos pudessem colaborar de forma eficiente e eficaz.

SQL

Usamos um banco de dados relacional SQL para realizar o cadastro de usuários que
iriam se conectar ao sistema. Structured Query Language, ou Linguagem de
Consulta Estruturada ou SQL, é a linguagem de pesquisa declarativa padrão para
banco de dados relacional (base de dados relacional).

MongoDB

Para armazenamento das mensagens optamos por utilizar o MongoDB. Ele é um

Banco de Dados Não Relacional, Orientado à Documentos. A definição geral
apresentada é que os Bancos de Dados orientados a Documentos utilizam o
conceito de dados e documentos autocontidos e auto descritivos, e isso implica que
o documento em si já define como ele deve ser apresentado e qual é o significado
dos dados armazenados na sua estrutura.
Banco de Dados Orientados a Documentos tem como característica conter todas as
informações importantes em um único documento, ser livre de esquemas, possuir
identificadores únicos universais (UUID), possibilitar a consulta de documentos
através de métodos avançados de agrupamento e filtragem (MapReduce) e também
permitir redundância e inconsistência.
Esses bancos de dados também são chamados de Bancos NoSQL (Not Only SQL).
Esse termo NoSQL é devido à ausência do SQL, mas esse tipo de Banco de Dados
não se resume apenas a isso, por isso o termo não é o mais correto para esse novo
tipo de Banco de Dados. No entanto, ele é aceito porque o termo já se popularizou
na comunidade. Alguns chegaram a defender o termo NoREL (Not Relational), mas
diferente do anterior este não foi muito aceito. De forma resumida esse tipo de
Banco de Dados não traz consigo as ideias do modelo relacional e nem a linguagem
SQL. Uma diferença fundamental entre os dois modelos surge quando precisamos
criar relacionamentos nos bancos de dados relacionais, diferente dos bancos
orientados a documentos que não fornecem relacionamentos entre documentos, o
que mantém seu design sem esquemas. Dessa forma, ao invés de armazenar dados
relacionados em uma área de armazenamento separado, os bancos de dados de
documentos integram esses dados ao próprio documento.
O MongoDB é um banco de dados orientado a documentos, diferente dos Bancos de
dados tradicionais que seguem o modelo relacional. Uma coisa interessante é que
por meio de um update o MongoDB permite que possamos acrescentar dados, isso
acontece porque não existe um esquema dentro das coleções, ou seja, as
collections podem ser dinâmicas. Essa possibilidade de uso de um update facilita
muito quando lidamos com mensagens e histórico delas na nossa aplicação.

Modelo cliente servidor

O modelo cliente-servidor (em inglês client/server model), em computação, é uma

estrutura de aplicação distribuída que distribui as tarefas e cargas de trabalho entre
os fornecedores de um recurso ou serviço, designados como servidores, e os
requerentes dos serviços, designados como clientes.
Geralmente os clientes e servidores comunicam através de uma rede de
computadores em computadores distintos, mas tanto o cliente quanto o servidor
podem residir no mesmo computador.
Um servidor é um host que está executando um ou mais serviços ou programas que
compartilham recursos com os clientes. Um cliente não compartilha qualquer de
seus recursos, mas solicita um conteúdo ou função do servidor. Os clientes iniciam
sessões de comunicação com os servidores que aguardam requisições de entrada.

JavaScript

JavaScript é uma linguagem de programação orientada à objetos. Entre outras

coisas, ela é utilizada para controlar o HTML e o CSS para manipular
comportamentos na página. Optamos por usar uma interface Web,
consequentemente a escolha de usar JavaScript e HTML como ferramentas em
conjunto com Java, MongoDB e SQL foi necessária. A fim de colocar em prática
diferentes conceitos desenvolvidos no curso e também explorar novas possibilidades
fizemos uma aplicação que roda tanto em um celular quanto em um PC, sem abrir
mão da linguagem orientada à objetos que o projeto exigia (a API no backend e o
servidor no backend utilizam-na).

HTML

HTML (abreviação para a expressão inglesa HyperText Markup Language, que

significa Linguagem de Marcação de Hipertexto) é uma linguagem de marcação
utilizada na construção de páginas na Web. Documentos HTML podem ser
interpretados por navegadores. A tecnologia é fruto da junção entre os padrões
HyTime e SGML.
HyTime é um padrão para a representação estruturada de hipermídia e conteúdo
baseado em tempo. Um documento é visto como um conjunto de eventos
concorrentes dependentes de tempo (como áudio, vídeo, etc.), conectados por
hiperligações. O padrão é independente de outros padrões de processamento de
texto em geral.
SGML é um padrão de formatação de textos. Não foi desenvolvido para hipertexto,
mas tornou-se conveniente para transformar documentos em hiper-objetos e para
descrever as ligações.
Projeto(estrutura) do programa
Relatório com linhas de código

https://github.com/GCastilho/unip-aps-5s

Api.java:

package api;

import org.bson.Document;
import org.json.JSONObject;
import org.json.JSONArray;
import java.io.IOException;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import database.DatabaseConnection;
import database.MongoConnection;

class Api {
static JSONObject process(JSONObject data) {
System.out.println("Message: " + data.toString());
JSONObject response = new JSONObject();

Map<String, Runnable> commands = new HashMap<>();

// Comandos reconhecidos (ok)

commands.put("hello", () -> {
 response.put("status", "ok");
response.put("info", "hi");
});

commands.put("send", () -> {
String sender = data.getString("userID");
String receiver = data.getString("receiver");
String message = data.getString("message");
if (sender.equals(receiver)) {
commands.get("badRequest").run(); return; }
try {
JSONObject mail = new JSONObject();
mail.put("status", "ok");
mail.put("command", "newMessage");
mail.put("sender", sender);
mail.put("message", message);
mail.put("timestamp", data.get("timestamp"));
if (DatabaseConnection.isGroup(receiver)) {
DatabaseConnection.getGroupUserList(receiver)
.forEach(user -> {
try{

ServerSocketHandler.send(user, mail.toString());
} catch (IOException e) {
e.printStackTrace();
}
});
} else {
ServerSocketHandler.send(receiver,
mail.toString());
 }

Document messageDoc = new Document();

messageDoc.put("sender", sender);
messageDoc.put("message", message);
messageDoc.put("timestamp", data.get("timestamp"));
if(data.has("file")){
byte[] file =
Base64.getDecoder().decode(data.getString("file"));
messageDoc.put("file", file);
messageDoc.put("fileExtension",
data.get("fileExtension"));
}

MongoConnection.addMessage(messageDoc, sender,
receiver);
} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("getMessages", () -> {
try {
response.put("status", "ok");
response.put("command", "getMessages");
String sender = data.getString("userID");
String receiver = data.getString("receiver");
List<Document> messageBatch;
if (data.has("lastID")) {
 String lastID = data.getString("lastID");
messageBatch =
MongoConnection.getMessageBatch(lastID, sender, receiver);
} else {
messageBatch =
MongoConnection.getMessageBatch("0", sender, receiver);
}
JSONArray messageList = new JSONArray();
messageBatch.forEach(message -> messageList.put(new
JSONObject(message.toJson())));
response.put("messageList", messageList);
} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("getChatList", () -> {
try {
response.put("status", "ok");
response.put("command", "getChatList");
List<String> userList =
DatabaseConnection.getUserList();
List<String> groupsList =
DatabaseConnection.getUserGroupList(data.getString("userID"));

response.put("userList", new JSONArray(userList));

response.put("groupsList", new JSONArray(groupsList));
} catch (Exception e) {
e.printStackTrace();
 commands.get("internalServerError").run();
}
});

commands.put("getChatUserList", () -> {
try {
String user = data.getString("userID");
response.put("status", "ok");
response.put("command", "getUserChatList");
response.put("userList", new
JSONArray(DatabaseConnection.getUserGroupList(user)));
} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("addNewGroup", () -> {
try {
String group = data.getString("groupName");
JSONArray arrJson = data.getJSONArray("users");
String[] users = new String[arrJson.length()];
for(int i = 0; i < arrJson.length(); i++) {
users[i] = arrJson.getString(i);
}

response.put("status", "ok");
response.put("command", "addNewGroup");
response.put("group",group);
 response.put("users",users);

DatabaseConnection.createGroup(group,users);
} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("addUserToGroup", () -> {
try {
String group = data.getString("groupName");
String user = data.getString("user");
response.put("status", "ok");
response.put("command", "addUserToGroup");
response.put("user",user);
DatabaseConnection.addGroupUser(group,user);

} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("removeUserFromGroup", () -> {
try {
String group = data.getString("groupName");
String user = data.getString("user");
response.put("status", "ok");
 response.put("command", "addGroup");
response.put("user",user);
DatabaseConnection.removeGroupUser(group,user);

} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

commands.put("getGroupUsers", () -> {
try {
String group = data.getString("groupName");
response.put("status", "ok");
response.put("command", "addGroup");

DatabaseConnection.getGroupUserList(group);

response.put("user",DatabaseConnection.getGroupUserList(group));
} catch (Exception e) {
e.printStackTrace();
commands.get("internalServerError").run();
}
});

// Comandos de erro
commands.put("commandNotFound", () -> {
response.put("status", "error");
response.put("info", "Command not found");
 });

commands.put("badRequest", () -> {
response.put("status", "error");
response.put("info", "Bad request");
});

commands.put("internalServerError", () -> {
response.put("status", "error");
response.put("info", "Internal server error");
});

if (data.has("command")) {
commands.getOrDefault(data.getString("command"),
commands.get("commandNotFound")).run();
} else {
commands.get("badRequest").run();
}

return response;
}
}

ServerSocketHandler.java:

package api;

import java.io.IOException;
import java.sql.SQLException;
import java.util.HashMap;

import database.DatabaseConnection;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;
import org.json.JSONObject;

import javax.xml.crypto.Data;

@WebSocket
public class ServerSocketHandler {
private final static HashMap<String, ServerSocketHandler> sockets = new
HashMap<>();
private Session session = null;
private String userID = null;
private String sessionID = null;

@OnWebSocketClose
public void onClose(Session session, int statusCode, String reason) {
System.out.println("Close: statusCode: " + statusCode + ", reason: " +
reason);

// Remove cookie from database

try {
DatabaseConnection.dropCookie(this.sessionID);
 } catch (Exception e) {
System.out.println("Error deleting cookie from database");
e.printStackTrace();
}

// Remove socket from map

ServerSocketHandler.sockets.remove(this.userID);
}

@OnWebSocketError
public void onError(Throwable t) {
System.out.println("Error: " + t.getMessage());
}

@OnWebSocketConnect
public void onConnect(Session session) {
// save session so we can send
this.session = session;

System.out.println("Connect: " +
session.getRemoteAddress().getAddress());

@OnWebSocketMessage
public void onMessage(String message) throws Exception {
JSONObject jsonMessage = new JSONObject(message);

JSONObject response = new JSONObject();

 if (userID == null) {
if (jsonMessage.get("command").equals("greetings")) {
try {
String sessionId =
jsonMessage.getString("sessionID");
sessionId =
sessionId.substring(sessionId.length()-128);
this.userID =
DatabaseConnection.getUser(sessionId);
this.sessionID = sessionId;

// map this userID to this connection

ServerSocketHandler.sockets.put(this.userID, this);

response.put("status", "ok");
response.put("info", "greetings");
} catch (SQLException e) {
response.put("status", "error");
response.put("command", "response");
response.put("info", "Internal server error");
} catch (Exception e) {
response.put("status", "error");
response.put("command", "response");
response.put("info", e.getMessage());
}
} else {
response.put("status", "error");
response.put("info", "Not logged in");
}
} else {
 if (DatabaseConnection.validCookie(this.sessionID)) {
DatabaseConnection.updateCookie(this.sessionID);
jsonMessage.put("userID", userID);
response = Api.process(jsonMessage);
} else {
response.put("status", "error");
response.put("info", "Not logged in");
}
}
if (!response.isEmpty()) this.sendClient(response.toString());
}

private void sendClient(String message) throws IOException {

this.session.getRemote().sendString(message);
}

static void send(String userID, String message) throws IOException {

// is the destination client connected?
if (ServerSocketHandler.sockets.containsKey(userID)) {
// get clientSession object from socketsMap
ServerSocketHandler clientSession = sockets.get(userID);
clientSession.sendClient(message);
}
}
}