Operações e Testes de Sistema de Arquivos no Shell

Introdução

Neste laboratório, você aprenderá a realizar diversos testes de arquivos no shell. Os testes de arquivos são ferramentas essenciais para verificar as propriedades de arquivos e diretórios no sistema de arquivos. Ao final desta prática, você estará familiarizado com os comandos de teste de arquivo mais comuns e seu uso, que são habilidades fundamentais para trabalhar em ambientes Linux.

Criando um Arquivo de Teste

Antes de começarmos com as operações de arquivo, é importante entender nosso ambiente de trabalho. No Linux, você sempre trabalha dentro de um diretório específico, e é crucial saber onde você está no sistema de arquivos.

Abra um terminal no WebIDE. É aqui que você digitará seus comandos.
Crie um novo arquivo chamado test_file.txt:
```
touch test_file.txt
```
O comando touch é usado para criar um arquivo vazio. Se o arquivo já existir, ele atualizará o carimbo de data/hora (timestamp) do arquivo sem alterar seu conteúdo.
Adicione algum conteúdo ao arquivo:
```
echo "This is a test file for our lab." > test_file.txt
```
Este comando usa o echo para exibir o texto e o operador > para redirecionar essa saída para dentro do arquivo. Tenha cuidado com o >, pois ele substituirá qualquer conteúdo existente no arquivo.
Verifique o conteúdo do arquivo:
```
cat test_file.txt
```
cat é uma abreviação de "concatenate" (concatenar), mas é frequentemente usado para exibir o conteúdo de um arquivo. Você deverá ver a mensagem "This is a test file for our lab."

Se você cometer um erro ou quiser recomeçar, pode sempre remover o arquivo com rm test_file.txt e começar novamente a partir do passo 1.

Testando a Existência de Arquivos

Agora que criamos um arquivo, vamos aprender como verificar se ele existe. Esta é uma tarefa comum em scripts shell, especialmente quando você precisa realizar operações em arquivos específicos.

Crie um novo arquivo de script chamado file_exists.sh:
```
touch file_exists.sh
```
Adicione o seguinte conteúdo ao arquivo:
```
#!/bin/bash

filename="test_file.txt"
if [ -e "$filename" ]; then
  echo "$filename exists"
else
  echo "$filename does not exist"
fi
```
Vamos analisar o código:
- #!/bin/bash é chamado de shebang. Ele informa ao sistema que este é um script bash.
- Definimos uma variável filename como "test_file.txt".
- A instrução if verifica se o arquivo existe. -e é um teste que retorna verdadeiro se o arquivo existir.
- Usamos o echo para imprimir uma mensagem baseada na existência ou não do arquivo.
Salve o arquivo e saia do editor.
Torne o script executável:
```
chmod +x file_exists.sh
```
Execute o script:
```
./file_exists.sh
```
Você deverá ver a saída: "test_file.txt exists"
Agora, vamos testar com um arquivo inexistente. Primeiro, vamos renomear nosso arquivo de teste:
```
mv test_file.txt non_existent.txt
```
Este comando renomeia test_file.txt para non_existent.txt.
Modifique o script para verificar o nome original do arquivo "test_file.txt":
```
nano file_exists.sh
```
Altere a variável filename para "test_file.txt" caso ela ainda não esteja configurada assim.
Execute o script novamente:
```
./file_exists.sh
```
Você deverá ver a saída: "test_file.txt does not exist"

Este script demonstra como verificar a existência de arquivos, o que é crucial quando seu script precisa manipular arquivos que podem ou não estar presentes.

Testando a Existência de Diretórios

De forma semelhante ao teste de existência de arquivos, também podemos verificar se um diretório existe. Isso é útil quando seu script precisa trabalhar com pastas que podem não ter sido criadas ainda.

Crie um novo arquivo de script chamado dir_exists.sh:
```
touch dir_exists.sh
```
Adicione o seguinte conteúdo ao arquivo:
```
#!/bin/bash

dirname="test_directory"
if [ -d "$dirname" ]; then
  echo "$dirname exists"
else
  echo "$dirname does not exist"
fi
```
Este script é muito parecido com o nosso script de existência de arquivo, mas utiliza -d em vez de -e. O teste -d verifica especificamente a existência de um diretório.
Salve o arquivo e saia do editor.
Torne o script executável:
```
chmod +x dir_exists.sh
```
Execute o script:
```
./dir_exists.sh
```
Você deverá ver a saída: "test_directory does not exist"
Agora, vamos criar o diretório e executar o script novamente:
```
mkdir test_directory
./dir_exists.sh
```
Agora você deverá ver a saída: "test_directory exists"

mkdir é o comando para criar um novo diretório.

Este script demonstra como verificar a existência de diretórios. Isso pode ser particularmente útil em scripts que precisam criar, modificar ou excluir pastas.

Testando Permissões de Arquivo

No Linux, cada arquivo e diretório possui permissões associadas que determinam quem pode ler, escrever ou executá-los. Nesta etapa, aprenderemos como verificar as permissões de um arquivo, especificamente se ele pode ser lido.

Primeiro, vamos renomear nosso arquivo de volta para o nome original:
```
mv non_existent.txt test_file.txt
```
Crie um novo arquivo de script chamado file_readable.sh:
```
touch file_readable.sh
```

Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash

filename="test_file.txt"
if [ -r "$filename" ]; then
  echo "You have read permission for $filename"
else
  echo "You do not have read permission for $filename"
fi

Este script utiliza o teste -r, que verifica se o arquivo possui permissão de leitura para o usuário atual.

Salve o arquivo e saia do editor.
Torne o script executável:
```
chmod +x file_readable.sh
```
Execute o script:
```
./file_readable.sh
```
Você deverá ver a saída: "You have read permission for test_file.txt"
Agora, vamos remover a permissão de leitura e executar o script novamente:
```
chmod -r test_file.txt
./file_readable.sh
```
Agora você deverá ver a saída: "You do not have read permission for test_file.txt"

O comando chmod -r remove as permissões de leitura do arquivo.
Restaure a permissão de leitura:
```
chmod +r test_file.txt
```
É importante restaurar as permissões para não deixarmos nosso arquivo ilegível acidentalmente.

Este script demonstra como verificar permissões de arquivos. Entender e gerenciar permissões é fundamental para a segurança do sistema e para o funcionamento correto de scripts.

Resumo

Neste laboratório, você aprendeu como realizar operações essenciais no sistema de arquivos através do shell. Você criou scripts para testar a existência de arquivos e diretórios, bem como permissões de acesso. Essas habilidades são fundamentais para trabalhar com arquivos e pastas em ambientes Linux e formam a base para tarefas de automação mais complexas.

Você praticou:

Compreensão do seu ambiente de trabalho
Criação e manipulação de arquivos
Escrita e execução de scripts shell
Teste de existência de arquivos e diretórios
Verificação de permissões de arquivos

Essas competências serão valiosas à medida que você continuar explorando sistemas Linux e desenvolvendo scripts mais avançados. Lembre-se de sempre verificar a existência de arquivos e diretórios antes de realizar operações neles para evitar erros em seus scripts. Além disso, esteja sempre atento às permissões ao lidar com dados sensíveis ou arquivos do sistema.

Conforme você progredir, poderá explorar testes de arquivos mais avançados, aprender sobre outras estruturas de script como loops e funções, e praticar a combinação desses conceitos para criar scripts mais robustos e poderosos.

Operações de Sistema de Arquivos no Shell