upload original files

Author: joaocotralha

README.md

@@ -0,0 +1,70 @@
+
+# Projeto de Sistemas Distribuídos 2020/2021
+
+Concretização de um serviço de armazenação de pares chave-valor. Iremos utilizar uma árvore binária de pesquisa para armazenar informação, dada a sua elevada eficiência ao nível da pesquisa. Sendo este tipo de serviço utilizado em sistemas distribuídos torna-se imperativa a troca de informação via rede.  Neste sentido foram desenvolvidos mecanismos de serialização/deserialização a utilizar no envio/receção de informação, utilizando o **protocol buffer**. Desta forma, pretende-se a concretização da árvore binária de pesquisa num servidor, e à implementação de um cliente com uma interface de gestão do conteúdo da árvore binária. Isto implica que:
+
+1. Através  do cliente,  o  utilizador  irá  invocar  operações,  que  serão  transformadas  em mensagens e enviadas pela rede até ao servidor.
+
+2. Este, por sua vez interpretará essas mensagens, e:
+a. Realizará as operações correspondentes na árvore local concretizada por ele.
+b. Enviará posteriormente a resposta transformada em mensagem, ao cliente
+
+3. Por sua vez, o cliente interpretará a mensagem de resposta
+4. O Cliente procederá  de  acordo  com  o  resultado,  ficando  de  seguida  pronto  para  a  próxima operação.
+
+O  objetivo será fornecer às aplicações que usariam esta árvore um  modelo de comunicação tipo **RPC**, onde vários clientes acedem a uma mesma árvore binária de pesquisa partilhada. Para tal, criámos um sistema concorrente que aceita pedidos de múltiplos clientes em simultâneo através do  uso  de multiplexagem  de I/O e que separa o tratamento de I/O do processamento de dados através do uso de *Threads*.
+
+Mais concretamente temos, para além da multiplexagem de I/O, foram implementadas:
+
+- Respostas assíncronas aos pedidos de escrita dos clientes, ou seja, em vez de executar imediatamente pedidos de escrita, o servidor devolve aos clientes um identificador da operação e passa a guardar os pedidos numa fila temporária para serem executados por uma thread
+- Garantia de sincronização e threads no acesso à árvore e à Fila de Tarefas através do uso de Locks e Variáveis Condicionais.
+
+No âmbito de suporte a tolerância a falhas, desenvolvemos um sistema de replicação com base no modelo de replicação passiva com primário fixo, através do serviço de coordenação **ZooKeeper**.
+
+Uma descrição mais detalhada do projeto em conjunto com a sua especificação encontra-se dividida pelos quatro enunciados.
+
+---
+
+## Estrutura
+
+`/include/`- contém os header *.h* requiridos pelo C
+`/source/` - contém o código fonte do projeto
+`/object/` - diretório que irá conter *object files*
+`/binary/` - executáveis resultantes do *linking* de *object files*
+`/lib/` - bibliotecas criadas na compilação
+
+Encontram-se também, na root do projeto:
+
+- README.md
+- makefile: define as regras de compilação e ligação
+- sdmessage.proto: esquema do *Protocol Buffer*
+
+---
+
+## Compilação e Execução
+
+Em baixo encontram-se comandos principais e alguns exemplos de utilização
+
+- **Compilação e ligação:** `make`
+
+- **Execução de um servidor:** `./binary/tree-server <porto_servidor> <IP:Porto Zookeeper>`
+Exemplo de utilização: `./binary/tree-server 12345 127.0.0.1:2181`
+
+- **Execução de um cliente:** `./binary/tree-client <IP Zookeeper> <Porto Zookeeper>`
+Exemple de utilização:  `./binary/tree-client 127.0.0.1 2181`
+
+- **Apagar ficheiros temporários:** `make clean`
+
+#### Importante
+
+Tanto o executável cliente como o executável servidor não devem ser chamados com o valor no campo IP de *"localhost"*, devendo em vez disso ser utilizado o endereço IP em notação XXX.XXX.XXX.XXX.
+
+---
+
+## Autores
+
+Projeto realizado por Grupo 59:
+
+  - **João Cotralha** Nº51090
+  - **Cláudio Esteves** Nº51098
+            

include/client_stub.h

@@ -0,0 +1,69 @@
+#ifndef _CLIENT_STUB_H
+#define _CLIENT_STUB_H
+
+#include "data.h"
+#include "entry.h"
+#include "zookeeper/zookeeper.h"
+
+/* Remote tree. A definir pelo grupo em client_stub-private.h
+ */
+struct rtree_t;
+
+/* Função para estabelecer uma associação entre o cliente e o servidor,
+ * em que address_port é uma string no formato <hostname>:<port>.
+ * Retorna NULL em caso de erro.
+ */
+struct rtree_t *rtree_connect(const char *address_port);
+
+struct rtree_t *zoo_connect(char *address_port);
+
+/* Termina a associação entre o cliente e o servidor, fechando a
+ * ligação com o servidor e libertando toda a memória local.
+ * Retorna 0 se tudo correr bem e -1 em caso de erro.
+ */
+int rtree_disconnect(struct rtree_t *rtree);
+
+/* Função para adicionar um elemento na árvore.
+ * Se a key já existe, vai substituir essa entrada pelos novos dados.
+ * Devolve 0 (ok, em adição/substituição) ou -1 (problemas).
+ */
+int rtree_put(struct rtree_t *rtree, struct entry_t *entry);
+
+/* Função para obter um elemento da árvore.
+ * Em caso de erro, devolve NULL.
+ */
+struct data_t *rtree_get(struct rtree_t *rtree, char *key);
+
+/* Função para remover um elemento da árvore. Vai libertar
+ * toda a memoria alocada na respetiva operação rtree_put().
+ * Devolve: 0 (ok), -1 (key not found ou problemas).
+ */
+int rtree_del(struct rtree_t *rtree, char *key);
+
+/* Devolve o número de elementos contidos na árvore.
+ */
+int rtree_size(struct rtree_t *rtree);
+
+/* Função que devolve a altura da árvore.
+ */
+int rtree_height(struct rtree_t *rtree);
+
+/* Devolve um array de char* com a cópia de todas as keys da árvore,
+ * colocando um último elemento a NULL.
+ */
+char **rtree_get_keys(struct rtree_t *rtree);
+
+/* Verifica se a operação identificada por op_n foi executada.
+ * devolve 0 se nao foi executada, caso contrario 1 ou -1 em erro
+ */
+int rtree_verify(struct rtree_t *rtree,int op_n);
+
+/* Liberta a memória alocada por rtree_get_keys().
+ */
+void rtree_free_keys(char **keys);
+
+void connection_watcher(zhandle_t *zzh, int type, int state, const char *path, void* context);
+
+static void child_watcher(zhandle_t *wzh, int type, int state, const char *zpath, void *watcher_ctx);
+
+#endif

include/data.h

@@ -0,0 +1,37 @@
+#ifndef _DATA_H
+#define _DATA_H /* Módulo data */
+
+/* Estrutura que define os dados.
+ */
+struct data_t {
+	int datasize; /* Tamanho do bloco de dados */
+	void *data;   /* Conteúdo arbitrário */
+};
+
+/* Função que cria um novo elemento de dados data_t e reserva a memória
+ * necessária, especificada pelo parâmetro size 
+ */
+struct data_t *data_create(int size);
+
+/* Função idêntica à anterior, mas que inicializa os dados de acordo com
+ * o parâmetro data.
+ */
+struct data_t *data_create2(int size, void *data); 
+
+/* Função que elimina um bloco de dados, apontado pelo parâmetro data,
+ * libertando toda a memória por ele ocupada.
+ */
+void data_destroy(struct data_t *data);
+
+/* Função que duplica uma estrutura data_t, reservando a memória
+ * necessária para a nova estrutura.
+ */
+struct data_t *data_dup(struct data_t *data);
+
+/* Função que substitui o conteúdo de um elemento de dados data_t.
+*  Deve assegurar que destroi o conteúdo antigo do mesmo.
+*/
+void data_replace(struct data_t *data, int new_size, void *new_data);
+
+#endif
+

include/entry.h

@@ -0,0 +1,44 @@
+#ifndef _ENTRY_H
+#define _ENTRY_H /* Módulo entry */
+
+#include "data.h"
+
+/* Esta estrutura define o par {chave, valor} para a tabela
+ */
+struct entry_t {
+	char *key;	/* string, cadeia de caracteres terminada por '\0' */
+	struct data_t *value; /* Bloco de dados */
+};
+
+/* Função que cria uma entry, reservando a memória necessária e
+ * inicializando-a com a string e o bloco de dados passados.
+ */
+struct entry_t *entry_create(char *key, struct data_t *data);
+
+/* Função que inicializa os elementos de uma entry com o
+ * valor NULL.
+ */
+void entry_initialize(struct entry_t *entry);
+
+/* Função que elimina uma entry, libertando a memória por ela ocupada
+ */
+void entry_destroy(struct entry_t *entry);
+
+/* Função que duplica uma entry, reservando a memória necessária para a
+ * nova estrutura.
+ */
+struct entry_t *entry_dup(struct entry_t *entry);
+
+/* Função que substitui o conteúdo de uma entrada entry_t.
+*  Deve assegurar que destroi o conteúdo antigo da mesma.
+*/
+void entry_replace(struct entry_t *entry, char *new_key, struct data_t *new_value);
+
+/* Função que compara duas entradas e retorna a ordem das mesmas.
+*  Ordem das entradas é definida pela ordem das suas chaves.
+*  A função devolve 0 se forem iguais, -1 se entry1<entry2, e 1 caso contrário.
+*/
+int entry_compare(struct entry_t *entry1, struct entry_t *entry2);
+
+#endif
+

include/message-private.h

@@ -0,0 +1,34 @@
+/*
+ * ######### Grupo 59 #########
+ * #   João Cotralha Nº51090  #
+ * #  Cláudio Esteves Nº51098 #
+ * #  José Salgueiro Nº50004  #
+ * ############################
+ */
+#ifndef _MESSAGE_PRIVATE_H
+#define _MESSAGE_PRIVATE_H
+
+#include "client_stub.h"
+#include "sdmessage.pb-c.h"
+#include "zookeeper/zookeeper.h"
+
+#include <netinet/in.h>
+
+struct message_t {
+  struct  _MessageT *message_t; // buff to msg
+  struct  _MessageT bmessage_t; //msg to buff
+};
+
+struct rtree_t{
+  struct sockaddr_in socket;
+  int server_flag;
+  int descritor;
+};
+
+void message_init(struct message_t *msg);
+
+int write_all(int sock, char *buf, int len);
+
+int read_all(int sock, char *buf, int len);
+
+#endif

include/network_client.h

@@ -0,0 +1,40 @@
+/*
+ * ######### Grupo 59 #########
+ * #   João Cotralha Nº51090  #
+ * #  Cláudio Esteves Nº51098 #
+ * #  José Salgueiro Nº50004  #
+ * ############################
+ */
+#ifndef _NETWORK_CLIENT_H
+#define _NETWORK_CLIENT_H
+
+#include "client_stub.h"
+#include "sdmessage.pb-c.h"
+
+/* Esta função deve:
+ * - Obter o endereço do servidor (struct sockaddr_in) a base da
+ *   informação guardada na estrutura rtree;
+ * - Estabelecer a ligação com o servidor;
+ * - Guardar toda a informação necessária (e.g., descritor do socket)
+ *   na estrutura rtree;
+ * - Retornar 0 (OK) ou -1 (erro).
+ */
+int network_connect(struct rtree_t *rtree);
+
+/* Esta função deve:
+ * - Obter o descritor da ligação (socket) da estrutura rtree_t;
+ * - Serializar a mensagem contida em msg;
+ * - Enviar a mensagem serializada para o servidor;
+ * - Esperar a resposta do servidor;
+ * - De-serializar a mensagem de resposta;
+ * - Retornar a mensagem de-serializada ou NULL em caso de erro.
+ */
+struct message_t *network_send_receive(struct rtree_t * rtree,
+                                       struct message_t *msg);
+
+/* A função network_close() fecha a ligação estabelecida por
+ * network_connect().
+ */
+int network_close(struct rtree_t * rtree);
+
+#endif

include/network_server.h

@@ -0,0 +1,40 @@
+#ifndef _NETWORK_SERVER_H
+#define _NETWORK_SERVER_H
+
+#include "tree_skel.h"
+
+/* Função para preparar uma socket de receção de pedidos de ligação
+ * num determinado porto.
+ * Retornar descritor do socket (OK) ou -1 (erro).
+ */
+int network_server_init(short port);
+
+/* Esta função deve:
+ * - Aceitar uma conexão de um cliente;
+ * - Receber uma mensagem usando a função network_receive;
+ * - Entregar a mensagem de-serializada ao skeleton para ser processada;
+ * - Esperar a resposta do skeleton;
+ * - Enviar a resposta ao cliente usando a função network_send.
+ */
+int network_main_loop(int listening_socket);
+
+/* Esta função deve:
+ * - Ler os bytes da rede, a partir do client_socket indicado;
+ * - De-serializar estes bytes e construir a mensagem com o pedido,
+ *   reservando a memória necessária para a estrutura message_t.
+ */
+struct message_t *network_receive(int client_socket);
+
+/* Esta função deve:
+ * - Serializar a mensagem de resposta contida em msg;
+ * - Libertar a memória ocupada por esta mensagem;
+ * - Enviar a mensagem serializada, através do client_socket.
+ */
+int network_send(int client_socket, struct message_t *msg);
+
+/* A função network_server_close() liberta os recursos alocados por
+ * network_server_init().
+ */
+int network_server_close();
+
+#endif

include/serialization.h

@@ -0,0 +1,47 @@
+#ifndef _SERIALIZATION_H
+#define _SERIALIZATION_H
+
+#include "data.h"
+#include "entry.h"
+#include "tree.h"
+
+/* Serializa uma estrutura data num buffer que será alocado
+ * dentro da função. Além disso, retorna o tamanho do buffer
+ * alocado ou -1 em caso de erro.
+ */
+int data_to_buffer(struct data_t *data, char **data_buf);
+
+/* De-serializa a mensagem contida em data_buf, com tamanho
+ * data_buf_size, colocando-a e retornando-a numa struct
+ * data_t, cujo espaco em memoria deve ser reservado.
+ * Devolve NULL em caso de erro.
+ */
+struct data_t *buffer_to_data(char *data_buf, int data_buf_size);
+
+/* Serializa uma estrutura entry num buffer que será alocado
+ * dentro da função. Além disso, retorna o tamanho deste
+ * buffer ou -1 em caso de erro.
+ */
+int entry_to_buffer(struct entry_t *entry, char **entry_buf);
+
+/* De-serializa a mensagem contida em entry_buf, com tamanho
+ * entry_buf_size, colocando-a e retornando-a numa struct
+ * entry_t, cujo espaco em memoria deve ser reservado.
+ * Devolve NULL em caso de erro.
+ */
+struct entry_t *buffer_to_entry(char *entry_buf, int entry_buf_size);
+
+/* Serializa uma estrutura tree num buffer que será alocado
+ * dentro da função. Além disso, retorna o tamanho deste
+ * buffer ou -1 em caso de erro.
+ */
+int tree_to_buffer(struct tree_t *tree, char **tree_buf);
+
+/* De-serializa a mensagem contida em tree_buf, com tamanho
+ * tree_buf_size, colocando-a e retornando-a numa struct
+ * tree_t, cujo espaco em memoria deve ser reservado.
+ * Devolve NULL em caso de erro.
+ */
+struct entry_t *buffer_to_tree(char *tree_buf, int tree_buf_size);
+
+#endif