Projeto POO - 2012.2

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar

O projeto final da disciplina Programação Orientada a Objetos poderá ser desenvolvido em dupla e deverá ser apresentado em sala.

Simulador de redes orientado a objetos

Nas redes de computadores as informações geradas por uma máquina origem trafegam por diversos dispositivos, como concentradores (hubs), comutadores (switchs) e roteadores, até chegar ao destino. Nessas redes os dados a serem transmitidos são divididos em pacotes e cada pacote é então enviado individualmente pela rede. Os pacotes possuem além da informação propriamente dita, um cabeçalho que contém informações como origem, destino, tamanho do pacote, etc.

O objetivo deste trabalho é desenvolver um simulador de rede que ao receber uma lista de pacotes a serem transmitidos, permita encaminhar estes pacotes até o destino. Cada dispositivo na rede deve então contabilizar o total de pacotes que processou e o total de pacotes que descartou. O simulador deve ainda fornecer uma interface para permitir ao usuário montar uma topologia de rede composta por um ou mais dos seguintes dispositivos: Computador, Concentrador e Comutador.

Descrição e funcionamento de cada dispositivo

  • Computador
    • Quantidade de portas: 1
    • Comportamento ao processar um pacote da sua fila: (1) Verifica se este é o emissor do pacote, se sim então encaminha o pacote para o dispositivo que está conectado em sua porta;(2) Verifica se este é o destinatário do pacote, se positivo contabiliza como pacote processado, senão descarta o pacote e contabiliza o descarte
  • Concentrador
    • Quantidade de portas: 8
    • Comportamento ao processar um pacote da sua fila: propaga o pacote para todos os dispositivos que estão conectados em suas portas, menos para a porta de onde recebeu o pacote. Ao propagar o pacote contabiliza-o como pacote processado
  • Comutador
    • Quantidade de portas: 8
    • Comportamento ao processar um pacote da sua fila: Verifica se o destinatário do pacote está conectado em uma de suas portas e se estiver então encaminha o pacote diretamente para o dispositivo. Caso não, propaga o pacote para todos os dispositivos que estão conectados em suas portas, menos para a porta de onde recebeu o pacote. Ao propagar o pacote contabiliza-o como pacote processado


Implementação do simulador

A implementação a ser desenvolvida sobre o código disponibilizado pelo professor aqui. O código disponível tem a seguinte organização:

  • Pacote poo: O código a ser desenvolvido deverá estar dentro deste pacote
    • Simulador.java
      • Possui parte do código de um simulador baseado em ciclos. A cada ciclo o simulador irá percorrer todos os dispositivos, executando uma única vez por ciclo o método processar() de cada dispositivo. O simulador ficará em execução até quando todos os dispositivos não possuírem mais pacotes em suas filas
      • Todos os N dispositivos (computadores, concentradores e comutadores) deverão estar armazenados em um vetor do tipo Dispositivo. As primeiras x posições serão destinadas para os Computadores, as próximas y posições são destinadas aos Concentradores e os Comutadores deverão ser armazenados nas próximas z posições, onde x+y+z = N
  • Pacote poo.util: Os códigos aqui servem de ajuda para desenvolver o trabalho
    • Dispositivo.java
      • Uma classe abstrata que servirá de base para a criação das classes Computador.java, Concentrador.java e Comutador.java
      • Todo dispositivo possui uma fila de pacotes de tamanho fixo que ao receber um pacote irá armazená-lo nesta fila, caso a mesma não esteja cheia. O comportamento de cada dispositivo deverá ser implementado dentro do método processar(). Os demais métodos abstract desta classe, por definição, também deverão ser implementados nas subclasses
    • Leitura.java
      • Classe abstrata que apresenta métodos para facilitar a obtenção de informações através do teclado
    • ManipuladorDeArquivos.java
      • Classe abstrata que apresenta métodos para carregar/gerar um arquivo que contém o tráfego a ser utilizado na simulação
    • Pacote.java
      • Classe que representa o pacote a ser transmitido pelos dispositivos da rede. Cada pacote tem três atributos: Origem, Destino e EncaminhadoPor


Particularidades do trabalho

A classe Pacote.java possui o atributo encaminhadoPor, no trabalho em questão este atributo é uma solução simplória contra a propagação indefinida de pacotes. Assim, os dispositivos Concentradores e Comutadores, ao fazerem uma difusão em massa, só não irão encaminhar o pacote para o dispositivo que estiver indicado no atributo encaminhadoPor. E antes de encaminhar o pacote para os demais dispositivos, estes deverão adicionar seus próprios identificadores no atributo encaminhadoPor.

Formato do arquivo texto com o tráfego

O tráfego a ser utilizado pelo simulador deverá ser carregado através de um arquivo texto no seguinte formato: origem>destino. Tanto a origem quanto o destino deverão ser Computadores. Segue abaixo um pequeno exemplo. Os números na primeira coluna representam os identificadores dos Computadores que são os emissores, já os números na terceira coluna representam os identificadores dos Computadores que são os destinatários do pacote. 


0>1
0>5
2>6
3>2


Formato do arquivo texto para carregar a topologia da rede

As três primeiras linhas do arquivo fazem parte do cabeçalho. Ali deve-se indicar o total de computadores na primeira linha, precedido dos caracteres c:; o total de concentradores, precedido dos caracteres h: ; e o total de comutadores, precedido dos caracteres s:. A partir da quarta linha deve-se indicar as conexões entre os dispositivos. Esta deve ser feita informando as posições dos dispositivos com o caractere - entre eles.

Abaixo é apresentado um exemplo para o arquivo de topologia. Neste exemplo tem-se 2 computadores, 2 concentradores e 1 comutador. O computador 0 está conectado ao concentrador 2; o concentrador 2 está conectado ao comutador 4; e o computador 1 está conectado ao concentrador 2. 


c:2
h:2
s:1
0-2
2-4
1-2

Observação: Ao processar o arquivo de topologia deve-se implementar uma validação do mesmo, pois o usuário pode ter criado um arquivo de topologia inválido. Por exemplo, o usuário pode não ter respeitado o formato explicitado acima; ou pode ter feito conexões inválidas entre dispositivos, como a conexão entre dois computadores, algo que não é permitido pela especificação do projeto.


Exemplo de uma rede e resultado da simulação

A figura abaixo apresenta uma topologia de rede composta por 12 computadores (0 -- 11), 2 concentradores (12--13) e 2 comutadores (14--15). Cada computador só possui uma porta para conectar qualquer outro dispositivo e neste exemplo todos os computadores estão conectados a um concentrador ou a um comutador. Cada concentrador e comutador possui 8 portas para conexões e nesta figura 1 concentrador e 1 comutador estão com 4 portas ocupadas. Já os demais concentradores e comutadores estão com 5 portas ocupadas.


Poo-2012-2-rede.jpg


Resultado da simulação para um único pacote enviado de 9 para 0

Com[0] processou: 1	 descartou: 0
Com[1] processou: 0	 descartou: 1
Com[2] processou: 0	 descartou: 1
Com[3] processou: 0	 descartou: 1
Com[4] processou: 0	 descartou: 1
Com[5] processou: 0	 descartou: 1
Com[6] processou: 0	 descartou: 1
Com[7] processou: 0	 descartou: 1
Com[8] processou: 0	 descartou: 1
Com[9] processou: 0	 descartou: 0
Com[10] processou: 0	 descartou: 1
Com[11] processou: 0	 descartou: 1
Hub[12] processou: 1	 descartou: 0
Hub[13] processou: 1	 descartou: 0
Swi[14] processou: 1	 descartou: 0
Swi[15] processou: 1	 descartou: 0
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Projeto_POO_-_2012.2&oldid=50420”