TRABALHO - Sistemas Operacionais - SO25CP - 2015/2

Bruno César Ribas

Prólogo

Para o trabalho de sistemas operacionais deste semestre, iremos implementar um CHAT. O CHAT será dividido em 3 checkpoints, a saber:

Troca de mensagens local por meio de FIFO e SINAIS;
Troca de mensagens local por meio de FIFO e THREAD;
~~Troca de mensagens global por meio de biblioteca de sockets e THREAD.~~
~~Cada checkpoint possuirá um valor de 30 pontos, exceto pelo terceiro que~~ ~~vale 40 pontos.~~
O primeiro checkpoint vale 30 pontos e o segundo checkpoint vale 70 pontos.

O primeiro Checkpoint

Entrega e apresentação: 21 de Outubro

Neste checkpoint o CHAT deverá funcionar localmente por meio de FIFO e SINAIS.

FIFO

O arquivo especial do tipo FIFO é uma fila, controlada pelo kernel.

Neste arquivo sempre que um processo abrir o arquivo para leitura ele ficará bloqueado durante a system call open até que outro processo abra o arquivo para escrita. Quando os dois processos fizerem as chamadas ambos serão liberados e poderão fazer a leitura e escrita, respectivamente, no arquivo.

Cada usuário deverá criar um arquivo do tipo FIFO (veja mkfifo(2) ) no diretório '/tmp/' no padrão, chat-usuario, onde usuario deverá ser substituído por um nome ou apelido.

Exemplo: Usuário 'Leonardo' deverá criar o arquivo FIFO no seguinte caminho:

  /tmp/chat-Leonardo

Para enviar uma mensagem a um usuário o programa CHAT deverá abrir a fifo do usuário de destino e escrever em texto plano uma mensagem no seguinte formato:

  DE:PARA:MENSAGEM

Exemplo: Usuário 'Leonardo' mandando para o usuário 'Marcelo' a mensagem "Ola amigo", deverá possuir o seguinte formato:

  Leonardo:Marcelo:Ola amigo

E para este exemplo, o CHAT de Leonardo deverá escrever esta mensagem em:

  /tmp/chat-Marcelo

As mensagens deverão, obrigatoriamente, encerrar com a quebra de linha.

O problema desta abordagem acontece quando o usuário origem da mensagem está a escrever na FIFO do outro usuário, como o processo fica bloqueado para escrita até que algum processo escreva a mensagem, a origem deverá avisar que está prestes a mandar uma mensagem.

A comunicação de envio de mensagens deverá ser feito por meio de sinal entre processos.

SINAIS

A comunicação de envio de mensagens deverá ser feito por meio do sinal USR1.

Sempre que um processo for enviar uma mensagem, ele deverá, antes de enviar a mensagem, avisar ao processo de destino da nova mensagem.

O sinal deverá ser enviado pelo comando kill(2).

Para enviar um sinal a um processo é obrigatório saber o PID do processo que receberá o sinal. Para isso, cada usuário, CHAT, deverá criar no diretório '/tmp/' um arquivo comum contendo o PID do processo CHAT.

O arquivo contendo o PID deverá ser criado em '/tmp/' um arquivo comum com a mesma nomenclatura do FIFO, com a extensão pid.

Por exemplo: O usuário Leandro deverá ter o arquivo pid:

  /tmp/chat-Leandro.pid

Fluxo de mensagens

Exemplo de fluxo de mensagens e sinais para o envio de uma mensagem do usuário A para o usuário B.

          1) 'A' envia sinal USR1 para 'B'
         ,--->----->---,
    ,___,               \___,
   /     \             /     \  2) 'B' desvia processo para função de recebimento de mensagem
  |usuario|           |usuario|     abre aquivo FIFO e fica travado até chegar mensagem
  |   A   |--->---->--|   B   |
  |       |3) 'A' es- |       | 4) 'B' recebe a mensagem, fecha o arquivo FIFO
   \_____/  creve na   \_____/      e continua o fluxo de execução.
            FIFO de 'B' a mensagem

Observações importantes

Após utilizada as FIFOS deverão ser, obrigatoriamente, FECHADAS;

Entrega e apresentação

Este checkpoint deverá ser apresentado na data limite por no máximo 10 minutos.

A apresentação deverá conter uma explicação do processo implementado, das principais dificuldades e o que foram feitas para contorná-las.

Além da apresentação os alunos deverão mostrar ao professor o CHAT em funcionamento.

O CHAT funcionar com o CHAT de outra equipe agrega 10 pontos ao checkpoint.

O segundo Checkpoint

Entrega e apresentação: ~~10/11/2015~~ 08/12/2015
Escopo: Thread
Os grupos serão, obrigatoriamente, os mesmos do primeiro checkpoint

O principal problema da abordagem utilizando sinais, como fizemos no checkpoint A, é a impossibilidade de haver chat entre usuários diferentes na máquina.

Esta impossibilidade ocorre pelo fato de que apenas processos do mesmo usuário podem mandar mensagens entre si. Este checkpoint surgiu diante da necessidade de usuários diferentes conseguirem efetuar a comunicação entre si.

Para garantir que diversos usuários diferentes, logados na mesma máquina, consigam se comunicar utilizando o CHAT, devemos abolir a necessidade de enviar sinais entre os processos durante o procedimento de envio de mensagens.

A questão fundamental: Como fazer com que o CHAT consiga ler novas mensagens enquanto envia sem ficar bloqueado. Para isso teremos que utilizar THREADS.

Deverá existir uma THREAD para ler mensagem, ou seja, a função que antigamente era ativada apenas pelo recebimento de um sinal deverá ser colocada em uma THREAD.

Além da THREAD de receber mensagem, deverá ser feita uma outra THREAD para enviar mensagens. Note que agora o processo do CHAT NÃO deverá ficar bloqueado enquanto está enviando uma mensagem.

Quando um usuário digita a mensagem e pressiona a tecla de envio, ENTER, esta mensagem recém redigida deverá ser enviada à THREAD de enviar mensagens. Note que o processo de enviar uma mensagem pode demorar e para isso a THREAD de enviar mensagens deverá ser capaz de acumular mensagens redigidas, armazenando em uma espécie de FILA.

Mudanças e padrões

O formato das mensagens deverá ser o mesmo utilizado no primeiro checkpoint;
- A mensagem apresentada ao usuário deverá ser formatada, excluindo o seu nome da mensagem impressa na tela. Por exemplo a mensagem a enviada para Marcelo de Ana, tem o seguinte formato:
```
  Ana:Marcelo:Ola
```
  O chat de marcelo deverá apresentar a mensagem da seguinte forma:
```
  Ana: Ola
```
  Note o espaço em branco após o ':' e a remoção da string do nome do receptor
O arquivo especial FIFO deverá ter permissão de escrita para todos usuários (habilitar o bit de WRITE para todos usuários), mas somente a escrita para todos os usuários, para o dono da fifo a permissão deverá ser apenas de leitura;
O chat deverá bloquear a saída quando o usuário apertar ^c (control+c), e deverá avisar que para sair deverá digitar o comando "sair". Quando o chat encerrar o FIFO e o arquivo contendo o PID deverão ser excluídos do sistema.
O chat não deverá ficar bloqueado enquanto uma mensagem é enviada, mesmo que o receptor demore para efetuar a leitura da mensagem.

O comando "list", deverá ser implementado no chat. Este comando lista todos os usuários disponíveis.
Quando o destinatário da mensagem for 'all' o chat deverá enviar a mensagem para todos os usuários disponíveis, colocando no campo de destino o nome "all".
- O chat deverá inibir que algum usuário tente entrar com o login "all".
- Exemplo de mensagem enviada para todos os usuários:
```
  Marcelo:all:Fala aí moçada.
```
- Quando o chat receber uma mensagem endereçada a 'all' deverá exibir na tela que a mensagem foi um broadcast da origem, exemplo para a mensagem acima no chat de Matheus:
```
  Broadcast de Marcelo: Fala aí moçada.
```

Fluxo de mensagens

Exemplo de fluxo de mensagens e sinais para o envio de uma mensagem do usuário A para o usuário B.

Neste exemplo a:

THREAD 1, representada por T1, será a thread que estará preparada para receber mensagens, ficando em um loop de leitura da FIFO;
THREAD 2, representada por T2, será a thread que está preparada para enviar mensagens a um usuário;
MAIN, thread principal, representada por Main, será responsável por ler a mensagem do usuário e enviá-la à thread responsável pelo envio de mensagens.

  /----------------\ 3)T1B está preparado para rece-   /----------------\
  |U     _______   |  ber conteúdo na     ,->---------------, _______   |
  |S     |     |   |  tela, processa a   /             |S    \>     |   |
  |U     | T1A |   |  informação e      /              |U     | T1B |   |
  |A     |     |   | apresenta na tela./               |A     |     |   |
  |R     ------- _.---------->--------'                |R     -------   |
  |I     _______/  |                                   |I     _______   |
  |O     |     |   |2)T2A consome a fila de mensagens  |O     |     |   |
  |      | T2A |   | a enviar e faz o procedimento de  |      | T2B |   |
  |A     |     |<-\| envio de mensagem, escrevendo     |B     |     |   |
  |      -------  ^| na FIFO do destinatário           |      -------   |
  |      _______  ^|                                   |      _______   |
  |      |     |  ||                                   |      |     |   |
  |      |MainA|  ||                                   |      |MainB|   |
  |      |     |-/ |                                   |      |     |   |
  |      -------   |1)Usuário A digita a mensagem e    |      -------   |
  |                |  pressiona enter para enviar.     |                |
  \----------------/  Esta mensagem é enviada para T2A \----------------/

Entrega e apresentação

Este checkpoint deverá ser apresentado na data limite por no máximo 10 minutos.

A apresentação deverá conter uma explicação do processo implementado, das principais dificuldades e o que foram feitas para contorná-las.

Além da apresentação os alunos deverão mostrar ao professor o CHAT em funcionamento.

Os alunos deverão demonstrar o domínio da solução implementada.

--O terceiro Checkpoint--

Entrega e apresentação: 08/12/2015
Escopo: Threads e funções externas
CANCELADO
No terceiro checkpoint a comunicação será feita pela internet. Uma biblioteca de conexão, envio e recebimento de mensagens a um servidor será fornecida pelo professor.
---
Last Modified: Wed Nov 4 14:25:53 2015.