DThor – Distribuição de Torrents por DHT

DThor – Distribuição de Torrents por DHT
André Braz - 27114
João Leite - 28247
Trabalho realizado sob a orientação de
Rui Pedro Lopes
Engenharia Informática
2013/2014
DThor– Distribuição de Torrents por DHT
Relatório da UC de Projeto
Licenciatura em Engenharia Informática
Escola Superior de Tecnologia e de Gestão
André Braz, João Leite
2013/2014
iii
A Escola Superior de Tecnologia e Gestão não se responsabiliza pelas opiniões expressas
neste relatório.
iv
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Rui Pedro Lopes
Orientador
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Arguente
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Arguente
Aceite para avaliação da UC de Projeto
v
vi
Dedicatória
Este projecto é dedicado a todos os nossos familiares e amigos por todo o apoio que nos
deram durante este período da nossa vida.
vii
viii
Agradecimentos
Em primeiro lugar gostaríamos de agradecer ao nosso orientador Rui Pedro Lopes pelo
acompanhamento e paciência que teve connosco ao longo do projecto. Queremos também
agradecer aos nossos pais por nos proporcionar as condições necessárias para a vida
académica. Finalmente agradecemos aos nossos amigos que estiveram sempre ao nosso lado e
que sempre nos apoiaram.
ix
x
Resumo
As redes Peer-to-Peer são constituídas por vários nós que partilham recursos. Este tipo de
redes também conhecidas como P2P, são construídas por elementos idênticos que se
organiza de forma a permitir a escalabilidade e a robustez das aplicações.
O protocolo BitTorrent assenta no princípio das redes P2P para potenciar a distribuição de
quantidades massivas de dados na Internet. Cada cliente (ou peer) tem a possibilidade de
partilhar e de descarregar ficheiros, recorrendo, para o efeito, a um ficheiro específico,
denominado .torrent. Este ficheiro será utilizado pelos peer destino para configurar a rede de
forma a obter o ficheiro, potencialmente a partir de vários peer em simultâneo.
As Distributed Hash Tables (DHTs) permitem armazenar e pesquisar pares (chave, valor), de
forma semelhante a uma tabela de hash sendo os valores armazenados em nós distribuídos na
Internet.
Tirando partido destas tecnologias propõe-se uma aplicação para armazenar, consultar e
eliminar .torrents específicos, associados a cada utilizador.
Palavras-chave: P2P, DHT, BitTorrent, torrent.
xi
xii
Abstract
The Peer-to-Peer networks are comprised of multiple nodes that share resources. Such
networks also known as P2P are constructed with identical elements that are organized to
allow scalability and robustness.
The BitTorrent protocol is based on the principle of the P2P networks to enhance the
distribution of massive amounts of data on the Internet. Each cliente (or peer) has the ability
to share and download files, using for this purpose a specific file called torrent. This file will
be used by the destination peer to configure the network to obtain the file, potentially from
multiple concurrent peers.
The Distributed Hash Tables (DHTs) can store and search pairs (key, value), similar to a hash
table with the values stored in nodes distributed in the Internet.
Taking advantage of the technologies we propose an application to store, search and delete
torrents associated with each user.
Keywords: P2P, DHT, BitTorrent, torrent
xiii
xiv
Conteúdo
1
2
Introdução ........................................................................................................................ 19
1.1
Objetivos ..................................................................................................................... 19
1.2
Estrutura do documento .............................................................................................. 20
Peer-To-Peer .................................................................................................................... 21
2.1 Organização dos nós ................................................................................................... 22
2.1.1 Arquitectura P2P Estruturada ............................................................................... 22
2.1.2 Arquitectura P2P Não Estruturada ....................................................................... 22
2.2 BitTorrent .................................................................................................................... 23
2.2.1 Ficheiro Torrent.................................................................................................... 24
2.3 DHTs ........................................................................................................................... 25
2.3.1 Mecanismo Genérico............................................................................................ 25
2.3.2 Armazenamento de Valores ................................................................................. 26
2.3.3 Kademlia .............................................................................................................. 27
3
4
Indexação .......................................................................................................................... 28
3.1
Crawling ...................................................................................................................... 28
3.2
Lucene ......................................................................................................................... 29
DThor................................................................................................................................ 30
4.1 Análise ........................................................................................................................ 30
4.1.1 Diagrama de Classes ............................................................................................ 30
4.1.2 Diagrama de Casos de Uso................................................................................... 33
4.1.3 Diagrama de Estados ............................................................................................ 34
4.1.4 Diagramas de Sequência ...................................................................................... 35
4.2 Desenvolvimento ........................................................................................................ 38
4.2.1 Java ....................................................................................................................... 38
4.2.2 NetBeans .............................................................................................................. 39
4.2.3 TomP2P ................................................................................................................ 39
4.2.4 Jetty ...................................................................................................................... 40
4.2.5 GitHub .................................................................................................................. 40
4.2.6 Aplicação .............................................................................................................. 40
4.3 Testes .......................................................................................................................... 42
4.3.1 Distribuição de Torrents na DHT ......................................................................... 42
4.3.2 Tempo de Pesquisa ............................................................................................... 44
5
Conclusões ........................................................................................................................ 46
xv
xvi
Lista de Figuras
Figura .1 – Diagrama de Classes - DThor. ........................................................................................................ 31
Figura .2 – Diagrama de Classes – Motor de Pesquisa. ................................................................................... 32
Figura .3 – Diagrama de Casos de Uso. ............................................................................................................. 33
Figura .4 – Diagrama de Estados. ...................................................................................................................... 34
Figura .5 – Diagrama de Sequências - Conectar. ............................................................................................. 35
Figura .6 – Diagrama de Sequências - Pesquisar. ............................................................................................ 36
Figura .7 – Diagrama de Sequências - Eliminar. .............................................................................................. 37
Figura .8 – Arquitetura da Aplicação................................................................................................................ 38
Figura .9 – Página Inicial.................................................................................................................................... 40
Figura .10 – Página de Upload. .......................................................................................................................... 41
Figura .11 – Página de Resultados. .................................................................................................................... 41
Figura .12 – Página de Confirmação para eliminar. ........................................................................................ 42
Figura .13 – Gráfico do Cenário 1. .................................................................................................................... 43
Figura .14 – Gráfico do cenário 2. ..................................................................................................................... 43
Figura .15 – Gráfico do cenário 3. ..................................................................................................................... 44
Figura .16 – Gráfico do tempo médio por pesquisa. ........................................................................................ 45
xvii
xviii
Capítulo 1
1 Introdução
Na década de 60 quando surgiu a internet todos os computadores ligados tanto eram
servidores como clientes, o que se encaixa na perfeição na definição de uma rede peer-topeer. Ao longo dos anos a sua estrutura foi-se alterando tornando-se como a conhecemos hoje,
com a estrutura cliente-servidor. Contudo esta estrutura tem-se tornado um problema.
Conforme a quantidade de informação disponível na internet aumenta apenas uma pequena
parte está disponível através de mecanismos de pesquisa por indexação.
Nos sistemas cliente-servidor os recursos estão concentrados em um pequeno número de nós
(servidores) que fornecem serviços aos clientes de forma contínua e confiável. Uma
alternativa a este sistema são os sistemas peer-to-peer. Neste sistema, cada peer (nó) funciona
como cliente e servidor ao mesmo tempo.
1.1 Objetivos
O objetivo principal é estudar e desenvolver uma aplicação, recorrendo a DHTs, para
armazenar, consultar e eliminar ficheiros .torrent específicos, associados a cada utilizador.
Cada utilizador pode aceder a estes ficheiros de forma escalável e de qualquer lado em
qualquer momento.
19
1.2 Estrutura do documento
Este documento está organizado em cinco capítulos – Introdução, Peer-to-Peer, Indexação,
DThor e Conclusões:
 Capítulo 1 - Introdução
Este capítulo tem como objetivo uma abordagem introdutória ao tema, bem como os
seus objetivos.
 Capítulo 2 – Peer-To-Peer
Este capítulo descreve o funcionamento das redes P2P bem como alguns protocolos
usados.
 Capítulo 3 - Indexação
Este capítulo aborda os conceitos de indexação e o processo de crawling.
 Capítulo 4 - DThor
Este capítulo apresenta as tecnologias usadas para o desenvolvimento da aplicação, a
sua arquitetura geral e os detalhes da implementação da mesma de modo a atingir a
aplicação final.
 Capítulo 5 - Conclusões
Este capítulo descreve as conclusões obtidas e a sumarização do trabalho realizado.
20
Capítulo 2
2 Peer-To-Peer
O P2P é o resultado do desenvolvimento e disponibilidade da tecnologia para a criação de
redes maiores.
Nas últimas décadas com o aumento de utilizadores as redes informáticas tornaram-se cada
vez maiores e mais poderosas e por sua vez a largura de banda tornou-se mais barata e de fácil
acesso.
Como consequência desse crescimento foram criadas aplicações baseadas na arquitectura P2P
o que despertou o interresse da comunidade. Um exemplo dessas aplicações foi o Napster que
se tornou o sistema P2P mais popular do dia para a noite.
O Napster era um software que podia ser obtido na Internet e que permitia o download de
qualquer música gratuitamente causando assim grandes prejuízos à indústria fonográfica.
Desde o aparecimento do Napster sugiram muitos outros sistemas P2P como Gnutela, KaZaa
e WinMP.
Na verdade o P2P surgiu da tecnologia utilizada nos tempos da Usenet e da FidoNet. Eram
duas redes totalmente descentralizadas, e sistemas como o DNS.
O DNS tornava-se uma necessidade uma vez que já existiam milhões de hosts na Internet.
Nessa altura a forma de navegar na Internet era através de um ficheiro .txt denominado
hosts.txt. Como a Internet cresceu, este sistema tornou-se impraticável surgindo assim o DNS.
Atualmente cada nó é conhecido como peer e funciona tanto como cliente e servidor. Quantos
mais peers existirem na rede mais estável, autónoma e eficiente esta se torna. [2]
21
2.1 Organização dos nós
Os nós encontram-se organizados numa rede overlay. Na rede overlay os nós são formados
pelos processos e as ligações são representadas pelos possíveis canais de comunicação. Um
processo apenas pode enviar mensagens para outro processo através dos canais de
comunicação disponíveis. Dois nós vizinhos numa rede overlay não são necessariamente
vizinhos na rede física.
A localização dos nós é processada na rede overlay através de um algoritmo de
encaminhamento distribuído implementado na camada de aplicação.
O encaminhamento permite que qualquer nó tenha acesso a um qualquer objeto na rede
overlay. Os sistemas P2P armazenam várias réplicas do mesmo objeto aumentado assim a
disponibilidade.
As redes overlay dividem-se em duas categorias: Estruturadas e Não Estruturadas.
2.1.1 Arquitectura P2P Estruturada
Numa rede P2P estruturada a rede overlay é construída através de um algoritmo
determinístico. O algoritmo mais utilizado é estruturar os processos numa DHT em que os
dados recebem uma chave aleatória e os nós da rede recebem um identificador.
O maior desafio num sistema baseado em DHTs é estruturar um esquema eficiente que
permita mapear unicamente a chave de um objeto para o identificador do nó que pretende
aceder ao objeto.
2.1.2 Arquitectura P2P Não Estruturada
Os sistemas P2P não estruturados normalmente baseiam-se em algoritmos aleatórios para
construir a rede overlay. Este sistema baseia-se na construção de uma tabela de vizinhos que é
gerada de forma aleatória em que cada nó e os dados também são armazenados de forma
aleatória nos nós.
22
Quando é necessário fazer a pesquisa de um objeto a rede é inundada com a pesquisa. Se dois
nós estiverem muito afastados na rede as pesquisas podem não ser respondidas uma vez que
existem mecanismos que impedem que mensagens se propaguem indefinidamente na rede.
Outra desvantagem é que a pesquisa é lenta uma vez que é gerado um grande volume de
tráfego ao inundar a rede.
Os sistemas P2P não estruturados mais conhecidos são o BitTorrent e o Gnutella.[2]
2.2 BitTorrent
O BitTorrent é um protocolo de rede que permite a partilha de ficheiros em redes P2P. Este
protocolo foi criado em Abril de 2001 pelo programador Bram Cohen, a versão inicial foi
lançada em 2 de Julho de 2001 e a versão final foi lançada em 2008. Os clientes BitTorrent
estão disponíveis numa grande variedade de plataformas e sistemas operativos.
O protocolo BitTorrent pode ser usado para reduzir o impacto na rede ao distribuir ficheiros
de grandes dimensões. Ao invés de descarregar um ficheiro a partir de único servidor o
BitTorrent permite aos utilizadores participarem num swarm de hosts para realizarem o
download e o upload em simultâneo. Usando o protocolo BitTorrent vários computadores
convencionais podem substituir servidores durante a distribuição de ficheiros para os clientes
permitindo um menor uso de largura de banda que ajuda a evitar picos de tráfego na Internet
em uma determinada área, mantendo a velocidade da Internet mais alta para todos os
utilizadores em geral.
Quando um utilizador pretende fazer upload de um ficheiro é necessário primeiro criar um
ficheiro .torrent. Os utilizadores que tiverem esse ficheiro podem atuar como peers ou
leechers.
O ficheiro a distribuir é divido em segmentos denominados peças (pieces). Como cada peer
recebe uma nova peça, este torna-se uma fonte para outros peers aliviando assim a carga do
peer original de ter que enviar a peça para outros utilizadores que o requisitem. Com o
BitTorrent a tarefa de distribuir o ficheiro é partilhada por aqueles que o querem.
Cada peça é criptografada com uma hash contida no ficheiro .torrent garantindo que qualquer
alteração na peça seja detetado de forma confiável. Um peer que possua o ficheiro .torrent
pode verificar a autenticidade do ficheiro que recebe.
23
As peças geralmente são transmitidas de forma não sequencial e são reorganizadas na ordem
correta pelo cliente BitTorrent, que monitoriza quais as peças que necessita e quais pode
enviar para os outros utilizadores.
À medida que mais utilizadores se juntam ao swarm a probabilidade que o download seja bem
sucedido é maior.[1]
2.2.1 Ficheiro Torrent
Um ficheiro .torrent é um ficheiro que contém metadados sobre ficheiros, pastas a serem
distribuídos e ainda a localização na rede dos trackers usados pelo protocolo BitTorrent.
Este ficheiro não contém o conteúdo a ser distribuído, apenas contém informação acerca dos
ficheiros, tais como, nome, tamanho e valores de hash para verificar a integridade do
ficheiro.[11]
Um ficheiro torrent é um dicionário bencoded com as seguintes chaves:
 Announce: É o URL do tracker.
 Info: Mapeia as chaves que são dependentes de um ou mais ficheiros para um
dicionário.
o Name: Sugere um nome para o ficheiro/pasta onde o ficheiro vai ser guardado.
o Piece Length: Número de bytes por piece.
o Pieces: Lista de hashs.
o Length: Tamanho do ficheiro em bytes.
o Files: Lista de dicionários onde cada um corresponde a um ficheiro, cada
dicionário contém as seguintes chaves:
 Path: Lista de strings correspondente ao nome do subdirectório onde a
última corresponde ao nome do ficheiro.
 Length: Tamanho do ficheiro em bytes.
24
2.3 DHTs
As DHTs (Distributed Hash Tables) são uma classe de sistemas distribuídos descentralizados
que fornecem um serviço de pesquisa semelhante a uma tabela de hash. Os pares (chave,
valor) são armazenados na DHT e qualquer nó pode aceder o valor associado a uma chave. O
mapeamento das chaves é distribuído entre os nós.
A investigação das DHTs foi motivada inicialmente por sistemas P2P como a Freenet,
Gnutella, BitTorrent e Napster, que tirou partido de recursos distribuídos através da Internet
para fornecer uma aplicação útil.
O Napster foi o primeiro sistema de distribuição de conteúdo P2P em larga escala. Era
necessário um servidor central e cada peer ao entrar iria enviar uma lista dos ficheiros
mantidos localmente para o servidor que iria efetuar pesquisas e remeter os resultados das
pesquisas. Este componente central deixou o sistema vulnerável a ataques e ações judiciais.
No Gnutella cada pesquisa resultava em uma mensagem a ser transmitida para todas as
máquinas na rede. Este método mostrou-se menos eficaz do que o Napster.
A Freenet é totalmente distribuída em que cada ficheiro está associado a uma chave e
ficheiros com chaves semelhantes tendem a agrupar-se em um conjunto semelhante de peers.
Na pesquisa as mensagens devem ser encaminhadas através da rede para um tal conjunto sem
a necessidade de visitar muitos peers mas no entanto não é garantido que os dados sejam
encontrados.
As DHTs usam um mecanismo de encaminhamento baseado em chaves mais estruturado no
sentido de alcançar a descentralização da Freenet e do Gnutella e a eficiência e garantia de
resultados do Napster. Uma desvantagem é que as DHTs apenas suportam pesquisas de
correspondência exata, em vez de pesquisa de palavras-chave.[3]
2.3.1 Mecanismo Genérico
Uma DHT apenas precisa uma operação o Lookup(k). Esta operação faz a pesquisa do nó
responsável pela chave K. Para inserir um novo valor na DHT é feito o lookup, e uma vez que
seja encontrado o nó é armazenado a chave e o valor.
25
Para armazenar um arquivo com um determinado nome e conteúdo em uma DHT realizam-se
os seguintes passos:
1) É realizado o hash SHA1 do nome do arquivo gerando uma chave K de 160 bits.
2) É enviada uma mensagem lookup(k) para um qualquer nó participante da DHT.
3) A mensagem é encaminhada de nó em nó ao longo da rede até encontrar o nó
responsável pela chave K.
4) Uma vez encontrada a referencia para o nó responsável armazena-se o conteúdo do
arquivo.
No caso de um cliente querer acessar um arquivo realizam-se os seguintes passos:
1) É realizado o hash SHA1 do nome do arquivo gerando uma chave K de 160 bits.
2) É enviada uma mensagem lookup(k) para um qualquer nó participante da DHT.
3) A mensagem é encaminhada de nó em nó ao longo da rede até encontrar o nó
responsável pela chave K.
4) Uma vez encontrada a referencia para o nó responsavel pela chave K o conteudo é
enviado para o cliente.
2.3.2 Armazenamento de Valores
A maioria das DHTs utiliza uma variante de uma hash consistente para mapear as chaves para
os nós. Cada nó possui uma chave (ID). Um nó com o ID i é o dono de todas as chaves para
as quais o i é o ID mais próximo.
São usados diferentes esquemas para mapear as chaves de modo a balancear a carga entre os
nós e a redirecionar um lookup por uma chave para um nó mais próximo do nó responsável.
O Chord usa a diferença matemática entre as chaves. O Pastry e o Tapestry usam o número de
bits em comum nas duas chaves. O Kademlia usa o XOR (ou exclusivo).
26
2.3.3 Kademlia
Para uma melhor percepção no funcionamento de uma DHT vamos dar como o exemplo o
Kademlia.
O Kademlia é uma DHT criada em 2002 por Petar Maymounkov e David Mazières. Os nós
comunicam entre si usando o protocolo UDP. A rede formada pelos nós participantes é
designada rede overlay. Cada nó é identificado por um ID, este não serve apenas para
identificação mas também para localizar valores. Na verdade o ID do nó fornece um mapa
direto para a hash do ficheiro e esse nó guarda informação de onde obter o ficheiro.
Ao pesquisar por algum valor o algoritmo de pesquisa necessita de conhecer a chave
associada e explora a rede em várias etapas. Cada etapa vai encontrar os nós que estão mais
perto da chave até que o nó contactado devolve o valor ou até quando não existem nós mais
perto. Este método é muito eficiente uma vez que o Kademlia apenas contacta log(n) nós
durante a pesquisa sendo n o número total de nós do sistema. A distância entre dois nós é
calculada através do “ou exclusivo” dos seus IDs resultando um número inteiro. As chaves e
os IDs têm o mesmo formato e comprimento de modo a que a distância possa ser calculada
entre eles.
As tabelas de encaminhamento do Kademlia consistem em uma lista para cada bit do ID do
nó. Cada entrada na lista contém os dados necessários para localizar outro nó. Os dados em
cada lista normalmente são o endereço IP, a porta e o ID do nó.
Quando os nós são encontrados na rede estes são adicionados às listas. Isto inclui operações
de armazenamento e de recuperação e até mesmo ajudar outros nós a encontrar uma chave.
Como o conhecimento de um novo nó é dinâmico a rede mantém-se constante atualizada
aumentando a resistência a falhas e ataques.
Cada vez que um nó pretende juntar-se à rede primeiro deve passar por um processo de
inicialização. Nesta fase o nó que pretende ingressar a rede precisa de saber o endereço IP e a
porta de um outro nó de inicialização que já participa na rede Kademlia. O nó de ingresso
insere então o nó de inicialização nas suas tabelas de encaminhamento. É efetuado de seguida
um pedido ao nó de inicialização que fará com que o ID do nó de ingresso seja adicionado às
tabelas de encaminhamento dos restantes nós e por consequência o nó de ingresso vai
adicionar os IDs dos outros nós às suas proprias tabelas de encaminhamento.[4]
27
Capítulo 3
3 Indexação
Information retrieval é o processo de obter recursos de informação relevante a partir de um
conjunto de recursos. As pesquisas podem ser baseadas em metadados ou em conteúdo
(indexação).
Para obter a informação de interesse para o utilizador, o utilizador deverá traduzir uma
necessidade de informação em uma pesquisa. Esta pesquisa é um conjunto de palavras chaves
que são utilizadas para recuperar informação numa coleção. A formulação da pesquisa
consiste em determinar quais são as palavras chaves que resumem a informação desejada pelo
utilizador.
Como resultado de uma pesquisa, a presença de informação não relevante nos resultados é
praticamente certa. Assim o objetivo da IR é retornar o mair número possível de informação
relevante e o menor possível de informação não relevante.
Para ser eficaz na tarefa de recuperar informação associada a uma pesquisa os sistemas IR
ordena a informação de acordo com o seu grau de relevância com a consulta do utilizador.[6]
3.1 Crawling
Um crawler é um programa autónomo ou um script que metódicamente procura ou “crawls”
através da internet informação relevante para indexação. Existem diversas utilidades para este
tipo de programas, sendo a principal motores de pesquisa.
Os crawlers não indexam a informação apenas a retorna para um parser que prepara os
documentos para serem indexados. O parser divide os documentos em diversas partes,
identificando campos e normalizando a informação para ser mais facilmente indexada.[10]
28
3.2 Lucene
O Lucene é uma biblioteca IR que permite pesquisar e indexar informação. É um projeto
open-source implementado em Java.
Para o Lucene a origem dos dados e o seu formato não são relevantes desde que estes possam
ser convertidos para texto.
Existem duas etapas principais no Lucene, indexação e pesquisa. A indexação processa os
dados originais gerando um estrutura de dados inter-relacionada eficiente para a pesquisa
baseada em palavras-chave. A pesquisa, por sua vez, consulta o índice pelas palavras-chave
inseridas em uma consulta e organiza os resultados pela similaridade de texto com a consulta.
No Lucene existe uma palavra chave em todo o processo denominado índice. O índice é uma
estrutura ordenada de texto ou pedaços de texto (tokens) o que torna a pesquisa mais eficiente.
Ao lermos texto para o Lucene este será primeiro submetido a um processo chamado
analisador (analyzer) que trata o texto. De seguida é criado um índice que pode ser baseado
no disco rígido ou na memória RAM. Tendo criado o índice há que criar um index writter de
modo a preenche-lo com informação.
Por último insere-se os documentos, criando os campos que forem necessários. Por vezes
pode haver a necessidade de guardar alguns campos para posteriormente serem devolvidos ao
utiliador, mas outros campos podem ser fúteis e são apenas guardados tokens dos mesmos.
Estes tokens são fragmentos de texto e não estão disponíveis para futuras recuperações.
Quando se pretende efetuar uma pesquisa é usado um indexSearcher, um QueryParser e a
localização do índice. Esta pesquisa vai depender do nome do campo a pesquisar e do
analisador igual ao usado na construção do índice. Os resultados são ordenados por ordem de
relevância, o Lucene tem este mecanismo que dá mais peso a documentos com maior
frequência do termo e a termos pouco comuns.[5][8]
29
Capítulo 4
4 DThor
O DThor é uma aplicação distribuída baseada em DHTs que permite adicionar, eliminar e
descarregar ficheiros .torrent de uma forma simplificada. É compatível com o Windows,
Linux, Mac OS X e em outros sistemas operativos que suportem Java.
4.1 Análise
4.1.1 Diagrama de Classes
O diagrama de classes que representa as entidades da aplicação DThor é ilustrado na figura 1
e as entidades do motor de pesquisa estão representadas na figura 2.
O DThor é constituído pelas classes DThorTorrent, DThorTomP2P, TorrentParser,
DThorConfig, JettyServer, DThorReplyKeys, TorrentUpload, TorrentSearch, TorrentDelete.
O motor de pesquisa é constituído pelas classes DThorTorrent, DThorTomP2P,
TorrentParser, DThorConfig, DThorCrawling, JettyServer, LuceneServer, TorrentDoc,
RemoteTorrentSearch, TorrentSearch, TorrentDelete.
30
Figura .1 – Diagrama de Classes - DThor.
A classe DThorTorrent têm um conjunto de atributos que define um ficheiro .torrent. É usada
para guardar a informação sobre o ficheiro .torrent.
A classe TorrentParser têm como objetivo fazer o parsing (análise) do conteúdo do ficheiro
.torrent. Esta classe permite ainda converter um objeto DThorTorrent para um ficheiro
.torrent.
A interface IDThor é usada para definir assinaturas de métodos que posteriormente são
implementadas na classe DThorTomP2P. A classe DThorTomP2P é responsável pelas
principais funcionalidades da aplicação tal como a gestão da DHT. Os principais métodos
desta classe são: addTorrent(), searchTorrent() e deleteTorrrent() que permitem adicionar,
pesquisar e remover torrents respetivamente.
A classe DThorReplyKeys tem um método responsável que aguarda e responde a pedidos
feitos pelo motor de pesquisa quando necessário. Quando recebe um pedido este obtém as
chaves conhecidas e retorna as.
31
A classe DThorConfig é responsável por carregar o ficheiro de configuração que contém
informação de inicialização da aplicação.
A classe JettyServer inicializa o servidor Web.
As servlets TorrentUpload, TorrentSearch e TorrentDelete são responsáveis respetivamente
por carregar, pesquisar e eliminar ficheiros .torrent.
Figura .2 – Diagrama de Classes – Motor de Pesquisa.
Uma vez que algumas classes já foram referidas anteriormente, não existe a necessidade de
serem referidas novamente.
A classe LuceneServer é responsável pela gestão do motor de pesquisa. Tem as seguintes
funcionalidades: indexação, pesquisa e remoção de índices associados a uma chave.
A classe TorrentDoc é fundamental para a indexação uma vez que faz o parsing dos campos
necessários para indexar um objeto DthorTorent.
Por fim a clase DThorCrawling tem como objetivo percorrer todos os peers da rede e
requisitar as chaves associados a cada um.
32
4.1.2 Diagrama de Casos de Uso
Figura .3 – Diagrama de Casos de Uso.
Este diagrama demonstra as principais atividades da aplicação. O cliente pode inserir,
pesquisar e eliminar torrents. Para eliminar um ficheiro .torrent é necessário primeiro efetuar
uma pesquisa do torrent pretendido. Ao se eliminar um torrent da DHT é necessário ainda
eliminar o índice da chave associado a esse torrent do motor de pesquisa uma vez que este já
não se encontra disponível para download.
33
4.1.3 Diagrama de Estados
Figura .4 – Diagrama de Estados.
A aplicação inicialmente encontra-se num estado de inicialização do peer onde em primeiro
lugar é carregado o ficheiro de configuração, em seguida o peer liga-se à rede e por fim é
inciado o servidor Web. Caso este processo inicial seja bem sucedido a aplicação fica num
estado de espera até o utilizador decidir qual a operação que pretende realizar.
Caso o utilizador pretenda fazer o upload de um ficheiro .torrent este é submetido e validado
e caso seja um ficheiro válido este vai ser adicionado à DHT.
34
Caso deseje pesquisar ou eliminar é necessário efetuar uma pesquisa onde é submetido um
pedido ao motor de pesquisa e onde este vai devolver os resultados ao utilizador. Por fim caso
o utilizador deseje fazer o download de um ficheiro este é obtido na DHT. Se por outro lado o
utilizador pretender eliminar um ficheiro este terá que inserir a chave de eliminação. Caso a
chave seja válida o ficheiro será eliminado da DHT e o índice respetivo a esse ficheiro será
eliminado no motor de pesquisa.
4.1.4 Diagramas de Sequência
Figura .5 – Diagrama de Sequências - Conectar.
Conectar Peer
Fluxo Principal
1. O peer contacta o super peer.
2. O peer executa o processo de bootstrap.
3. O super peer retorna a lista dos peers conhecidos.
35
4. O peer conecta-se aos outros peers da rede.
5. O peer inicia o seu servidor Web.
Figura .6 – Diagrama de Sequências - Pesquisar.
Pesquisa
Fluxo Principal
1. O peer envia um mensagem ao motor de pesquisa contendo a query de pesquisa.
2. O motor de pesquisa retorna o resultado da pesquisa.
3. O utilizador seleciona o ficheiro .torrent que pretende obter e esse é procurado na
DHT.
4. É devolvido o ficheiro para download ao utilizador.
36
Figura .7 – Diagrama de Sequências - Eliminar.
Eliminar
Fluxo Principal
1. O peer envia uma mensagem ao motor de pesquisa contendo a query de pesquisa.
2. O motor de pesquisa retorna o resultado da pesquisa.
3. O utilizador seleciona o ficheiro que pretende eliminar.
4. É pedido ao utilizador a chave de eliminação do ficheiro.
5. O peer efetua o pedido de eliminação.
6. A chave é validada e o torrent é eliminado.
7. O peer pede ao motor de pesquisa para eliminar o índice relativo ao torrent que foi
eliminado.
Fluxo de Exceção
Caso a chave de eliminação seja inválida o utilizador terá a necessidade de a inserir
novamente até que esta seja válida.
37
4.2 Desenvolvimento
Pretende-se com o presente trabalho, desenvolver uma aplicação para adicionar, eliminar e
descarregar ficheiros .torrent.
Na figura 8 é apresentada a arquitectura geral do sistema implementado.
Figura .8 – Arquitetura da Aplicação.
Para o desenvolvimento deste projeto foi utilizado o IDE Netbeans, recorreram-se às
bibliotecas TomP2P, Jetty e Lucene. Esta aplicação foi implementada em Java devido ao
facto da sua compatibilidade com vários dispositivos.
4.2.1 Java
É uma linguagem de programação concorrente baseada em classes e orientada por objetos.
Foi especialmente desenhada para que quando for executada numa plataforma, não necessita
38
de ser recompilada. As aplicações Java são compiladas em bytecode que pode correr em
qualquer máquina virtual Java (JVM) independentemente da arquitetura do computador.
4.2.2 NetBeans
O NetBeans é um IDE gratuito e open source para programadores de software. É executado
em várias plantaformas como Windows, Linux, MacOS. O NetBeans oferece aos
programadores as ferramentas necesárias para criar aplicações profissionais, empresariais,
Web e móvel.
4.2.3 TomP2P
O TomP2P é uma biblioteca de DHTs que permite armazenar informação em pares(chave,
valor). Cada peer tem uma tabela que guarda os seus valores. Tem por base a framework Java
NIO para comunicar, o que permite suportar várias conexões em simultâneo.
Permite configurar o NAT automaticamente. Se um peer não estiver acessível pelo endereço
externo, o TomP2P vai tentar configurar o encaminhamento de portas no router usando UPnP
e NATPMP.
É possível detetar se já existe uma regra de encaminhamento de portas existente no local.
Primeiro o peer que se encontra atrás do NAT precisa de contatar um peer conhecido,
tipicamente o peer de bootstrap. Este peer relata como o peer é visto, e com essa informação o
peer que se encontra atrás do NAT pode descobrir como fazer o encaminhamento.
No TomP2P existem dois tipos de replicação de dados, directa e indireta. A replicação direta
pode ser descrita pela constante atualização do conteúdo pelo qual é responsável. Caso um
peer abandone a rede todo o seu conteúdo é eliminado. Na replicação indereta a replicação
pode ser descrita como a distribuição de conteúdo de uns peers para outros. O peer mais
proximo da chave de um ficheiro é considerado o peer responsável por esse ficheiro e replicao se necessário.[12]
39
4.2.4 Jetty
O Jetty é um servidor HTTP(Web) que suporta Java Servlets. É usado normalmente para
comunicações entre máquinas e suporta as últimas versões da Java Servlet API.
É um projeto open source e faz parte da fundação Eclipse.[9]
4.2.5 GitHub
O GitHub é um serviço de Web Hosting Git para gestão de revisões de projetos. Oferece uma
interface gráfica na Web, desktop e integração móvel. Fornece controlo de acesso e várias
funcionalidades de colaboração, tais como wikis, gestão de tarefas, acompanhamento de bugs
e solicitações de recursos.
O GitHub tornou-se extremamente importante que a comunidade de desenvolvimento open
source começou a considerá-lo como um substítuto ao currículo convencional e alguns
empregadores exigem que os requerentes forneçam um link para a sua conta do GitHub a fim
de se qualificar para um emprego.[7]
4.2.6 Aplicação
 Página Inicial
Quando a aplicação é iniciada é apresentada a página inicial representada na figura 9.
Figura .9 – Página Inicial.
40
 Página de Upload
Figura .10 – Página de Upload.
 Página de Resultados
Figura .11 – Página de Resultados.
41
 Janela de confirmação para eliminar
Figura .12 – Página de Confirmação para eliminar.
4.3 Testes
4.3.1 Distribuição de Torrents na DHT
Para um melhor conhecimento acerca da distribuição dos torrents ao longo da DHT foi
realizado um teste com três cenários onde foi determinado o número de torrents armazenado
por cada peer. A diferença entre os três cenários reside no número e peers na rede em que
cada um continha, 10, 100 e 1000 peers respetivamente. Em ambos os cenários foram
adicionados 10000 torrents aleatoriamente na rede.
As figuras que se seguem apresentam os resultados obtidos.
42
Figura .13 – Gráfico do Cenário 1.
Figura .14 – Gráfico do cenário 2.
43
Figura .15 – Gráfico do cenário 3.
Com base nos resultados obtidos podemos observar que a distribuição dos torrents não é
uniforme isto deve-se ao facto de que cada peer armazena as chaves com o ID mais próximo
do seu ID e posteriormente o peer responsável por esse chave vai replicá-la para os peers mais
próximos.
Em média cada peer armazena 60000, 6000 e 600 torrents respetivamente em cada cenário o
que leva a concluir que cada torrent inserido é replicado 6 vezes na rede.
4.3.2 Tempo de Pesquisa
Para avaliar o desempenho da DHT em termos de pesquisa foi realizado um teste com três
cenários onde foi medido o tempo médio de pesquisa. A diferença entre os três cenários reside
no número de peers na rede em que cada um continha 10, 100 e 1000 peers respetivamente.
Em ambos os cenários foram adicionados 10000 torrents aleatóriamente na rede.
Com a realização deste teste foi obtido o gráfico da figura 16.
44
Figura .16 – Gráfico do tempo médio por pesquisa.
Com base nos resultados obtidos podemos observar que existem variações no tempo médio de
pesquisa entre os três cenários. Isto deve-se ao facto de que os torrents encontram-se mais
dispersos na DHT logo é necessário percorrer mais peers para encontrar o peer responsável
pelo ficheiro .torrent.
45
Capítulo 5
5 Conclusões
De um modo geral os objetivos inicialmente definidos foram cumpridos com sucesso. Depois
de um grande estudo sobre a temática geral do projeto, o conhecimento sobre esta matéria
ficou bem assimilado uma vez que nos era praticamente desconhecido e despertou-nos
bastante interesse.
Uma vez que a DHT apenas permite pesquisas do tipo (valor, chave) exatas optamos por
melhorar o projeto inicial implementando um motor de pesquisa permitindo assim pesquisas
do tipo palavra-chave. Com o motor de pesquisa a aplicação tornou-se mais funcional e
flexível.
Durante a realização do projeto ocorreram alguns entraves, tais como, a falta de
documentação de algumas bibliotecas utilizadas e a consequente dificuldade de compreensão
da sua utilização.
46
Referências bibliográficas
[1]
BitTorrent, Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/w/index.php?title=BitTorrent
[2]
Peer-to-Peer, Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Peer-to-peer
[3]
Distributed Hash Table, Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Distributed_hash_table
[4]
Kademlia, Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Kademlia
[5]
Lucene, Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Lucene
[6]
Information Retrieval, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Information_retrieval
[7]
GitHub, the Free Encyclopedia.
http://en.wikipedia.org/wiki/GitHub
[8]
McCandless, Michael, Erik Hatcher, e Otis Gospodnetic. Lucene in Action, Second Edition:
Covers Apache Lucene 3.0.2 edition.
[9]
Jetty (web Server), Wikipedia, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Jetty_%28web_server%29
[10]
Web Crawler, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Web_crawler
[11]
Torrent File, the Free Encyclopedia.
http://en.wikipedia.org/wiki/Torrent_file
[12]
TomP2P, A P2P-based high performance key-value pair storage library
http://tomp2p.net/
47