Como realizar uma tarefa quando um novo arquivo é adicionado a um diretório no Linux

Este tutorial mostrará como usar os eventos do sistema de arquivos Linux (notificação) para ser notificado sempre que um arquivo aparecer em um diretório. Você pode usá-los como gatilhos para automatizar tarefas comuns em seu sistema.

Vamos escrever um script que observa um diretório e atua nos novos arquivos que são adicionados. Cada arquivo é compactado e movido para outro diretório, assim que for detectado. O script usa o subsistema inotify, por meio de um utilitário chamado inotify-tools. Mas primeiro, vamos instalar a ferramenta e experimentar.

Instalação de ferramentas inotify e gzip

Use apt-getpara instalar este pacote em seu sistema se você estiver usando o Ubuntu ou outra distribuição baseada em Debian. Em outras distribuições Linux, use a ferramenta de gerenciamento de pacotes da distribuição Linux.

sudo apt-get install inotify-tools gzip

Experimentar com ferramentas inotify

Vamos começar observando um diretório e ver quais eventos são iniciados quando novos arquivos chegam. Usaremos uma ferramenta chamada   inotifywatch, que faz parte do inotify-tools. Crie um novo diretório chamado “entrando”:

mkdir entrando

Comece a monitorar este diretório executando o seguinte comando:

inotifywatch -v entrando

Isso instruirá o inotify a observar todos os eventos do sistema de arquivos no diretório de “entrada”. A -vopção faz com que a ferramenta imprima informações extras sobre o que está fazendo. Não especificamos uma opção de tempo limite (-t), e o comando continuará reunindo eventos até sairmos com CTRL + C. Neste ponto, nosso terminal deve ser parecido com isto:

Abra uma nova janela de terminal (ou guia) e mude para o diretório de entrada. Use o comando touch para criar um novo arquivo chamado “newfile”.

cd entrando /
toque em newfile

Agora volte para a primeira janela do terminal e pare o inotifywatch pressionando CTRL + C.

Uma tabela de eventos será exibida no console, indicando uma instância de “criar”, “abrir”, “atribuir” e “fechar_escrever”. Esses quatro eventos ocorreram quando usamos o toque para criar um novo arquivo, definir seus atributos de acesso ao arquivo, abri-lo para escrever um caractere de terminação nulo e, em seguida, fechá-lo depois. Estes são apenas alguns dos vários eventos que podem ser monitorados em um sistema de arquivos com ferramentas inotify. Você pode ver a lista completa na página principal do inotifywatch.

Para nossos propósitos, estamos interessados ​​apenas em dois eventos:

• “Criar” – quando um arquivo é criado no diretório de destino.
• “Moved_to” – quando um arquivo é movido de outro local para o diretório de destino.

Vamos tentar o inotifywatch novamente, mas desta vez instruindo-o a monitorar apenas esses dois eventos. Execute este comando na primeira janela do terminal:

inotifywatch -v -e criar -e moved_to entrante

Na segunda janela ou guia do terminal, vamos tentar criar um novo arquivo, alterando seu conteúdo e, a seguir, movendo o arquivo de outro local para o diretório de destino. Todos esses comandos são executados no diretório inicial.

toque recebido / criado
echo Testing123 >> recebido / criado
toque em / tmp / created2
mv / tmp / created2 entrando /

Volte para a primeira janela do terminal e pare o inotifywatch pressionando CTRL + C. Veremos a seguinte saída:

Apenas dois eventos foram contabilizados: a criação de um arquivo denominado “created.txt” e a movimentação de um arquivo existente denominado “created2.txt”. Todo o resto, como modificar “created.txt,” foi ignorado.

Assistindo a um diretório e executando uma tarefa

Agora que sabemos quais eventos seguir, podemos usar outra ferramenta chamada   inotifywaitpara bloquear a execução até que um arquivo seja criado ou movido para nosso diretório de destino. Usaremos os mesmos argumentos que fizemos com inotifywatch e também especificaremos como queremos que o nome do arquivo seja formatado para uso em nossa tarefa.

Antes de começar, precisamos de um diretório para armazenar os arquivos que já foram processados. Crie um diretório chamado “processado”:

mkdir processado

Em seguida, crie um novo script chamado “watch-incoming.sh” e adicione os conteúdos listados abaixo:

#! / bin / bash

TARGET = ~ / entrando /
PROCESSADO = ~ / processado /

inotifywait -m -e criar -e moved_to --format "% f" $ TARGET \
        | enquanto lê FILENAME
                Faz
                        eco detectado $ FILENAME, movendo-se e fechando
                        mv "$ TARGET / $ FILENAME" "$ PROCESSED / $ FILENAME"
                        gzip "$ PROCESSED / $ FILENAME"
                feito

O script executa o   inotifywaitcomando com a -mopção. Isso faz com que o monitor de comando mude indefinidamente. Cada vez que um novo evento é detectado, o nome do arquivo é passado para o comando de leitura e injetado na variável “FILENAME”. O bloco sob o loop while é executado, no qual o arquivo é primeiro movido para o diretório “processado” e então compactado. O arquivo original é substituído pelo arquivo compactado e o nome do arquivo terminará em “.gz”.

Vamos conceder permissões de execução neste script e executá-lo em nosso diretório inicial.

chmod u + x watch-incoming.sh
./watch-incoming.sh

Abra a segunda janela do terminal e crie um novo arquivo no diretório “entrando”. Liste o conteúdo do diretório “recebido” e “processado” para ver os resultados do evento sendo detectado:

O arquivo de texto bruto que copiamos para o diretório “entrando” foi detectado pelo script, copiado para “processado” e então compactado usando gzip.

Podemos fazer algumas tarefas interessantes agora que podemos observar novos arquivos que chegam em um diretório. Por exemplo, poderíamos adicionar uma marca d’água aos arquivos de imagem, compactar vídeos brutos no formato mp4 e até mesmo fazer upload de cada novo arquivo que vemos em um balde Amazon S3. Este script é um bom ponto de partida para implantar seus próprios fluxos de trabalho e automatizar tarefas comuns em seu sistema.