Este programa foi marcado como "Limpo" pelo anfitrião.
01 Introdução
Neste episódio, eu descreverei técnicas para baixar podcasts utilizando comandos de shell básicos, como o wget.
Eu vou ilustrar isso usando um script bash que pode ser usado para baixar podcasts do HPR.
Mesmo que você não tenha interesse em baixar seus podcasts usando esse método, você pode achar algumas das técnicas úteis ou interessantes.
São os princípios que são discutidos aqui que são importantes, e não a implementação.
02
Eu percebo que já existem vários programas diferentes para download de podcasts disponíveis, incluindo pelo menos um escrito em bash.
No entanto, você pode sentir que nenhuma dessas opções se adapta ao modo como deseja fazer as coisas e deseja criar seu próprio sistema personalizado de acordo com suas necessidades específicas.
Se for o caso, espero que o seguinte seja útil para você.
Se não for, você ainda pode encontrar interessante algumas das coisas discutidas aqui.
Alguns dos assuntos que abordo incluem
wget para um nome de arquivo definido pelo usuário.
Analisando XML com xmllint.
Usando inotifywait para acionar uma ação quando um arquivo é criado ou modificado.
Utilizando notify-send para enviar uma mensagem para a área de notificação.
e
Uma maneira de permitir que um trabalho em cron envie uma mensagem para a interface do usuário.
03 Fundo
Tem havido uma discussão contínua nos comentários de alguns episódios do HPR sobre problemas no download dos episódios do podcast HPR.
Parece que algumas pessoas têm enfrentado problemas com a estrutura dos URLs dos episódios.
04
Tenho medo de que não compreenda totalmente a natureza desses problemas, então não abordarei esse problema diretamente.
Em vez disso, apresentarei um script Bash que escrevi e que pode ser usado para baixar podcasts HPR.
Este script Bash pode ser executado usando cron para buscar automaticamente novos podcasts HPR e salvá-los em um diretório designado.
Esta é uma versão simplificada de um script que uso há anos para baixar podcasts HPR e outros.
05
Eu não vou tentar ler o script completo do bash neste podcast, pois seria um pouco chato de ouvir.
Em vez disso, vou descrever o que cada seção faz e por que escolhi fazer as coisas dessa maneira.
Talvez outras pessoas possam oferecer sugestões de maneiras melhores de fazer as coisas.
Vou postar o script completo do bash nas notas do show.
06 Buscando Podcasts
A maneira padrão de distribuir podcasts é publicar um feed RSS que contenha links para os arquivos de áudio.
O RSS é um mecanismo bem estabelecido e amplamente suportado para isso e outros propósitos.
Um feed RSS é, basicamente, um documento XML que pode ser acessado via HTTP.
Esses URLs contidos no documento XML RSS podem ser utilizados para baixar os arquivos de áudio reais, como arquivos MP3 ou OGG.
07
Basicamente, o que precisamos fazer é o seguinte:
• Baixar o documento XML RSS.
• Extrair os links para os arquivos de áudio.
• Comparar a lista desses links com uma lista salva anteriormente para ver quais são novos e quais já foram baixados anteriormente.
08
• Criar uma lista dos novos URLs.
• Passar por essa lista de novos URLs e baixar cada um dos novos arquivos de áudio.
• Verificar se realmente recebemos o novo arquivo de áudio.
Adicione os URLs dos arquivos que conseguimos baixar à nossa lista salva de URLs de podcasts.
09
Além disso, gostaríamos que isso acontecesse automaticamente em segundo plano, sem que precisássemos tomar nenhuma ação por conta própria.
Talvez também queiramos receber uma notificação quando um novo podcast chegar.
Provavelmente, também gostaríamos de receber notificação de quaisquer erros ou falhas.
10 Buscando Podcasts - As Preliminares
Nosso desejo de poder executar o script automaticamente impõe algumas exigências à nossa solução.
Para agendar o script, usaremos o cron.
Cron é uma ferramenta do Linux para executar scripts em horários programados.
11
Um dos efeitos colaterais do uso do cron é que precisamos especificar o caminho completo para os locais onde pretendemos manter quaisquer arquivos de dados, além do caminho completo para onde pretendemos colocar os podcasts baixados.
12
Então, a primeira coisa que precisamos fazer no nosso script é especificar vários valores para coisas como localização de arquivo, URL do feed RSS do HPR e vários outros detalhes também.
Pulari os detalhes desses, embora possa me referir a eles mais tarde.
Obter os dados RSS
A primeira coisa de substância a fazer é buscar os dados do feed RSS atual.
Coloquei isso em uma função bash chamada getrssurldata.
O conteúdo dessa função é uma linha única, mas com vários elementos encadeados por meio de pipes.
Baixar o documento RSS XML
Usamos inicialmente o `wget`, que é um comando padrão na maioria das distribuições Linux.
Especificamos quatro coisas.
Primeiro, definimos um tempo limite. Escolhi 20 segundos.
Em seguida, definimos o limite de tentativas. Escolhi 3.
15
Depois, especificamos que a saída do `wget` é enviada para o `stdout` em vez de ser salva como um arquivo.
Isso é feito utilizando a opção `-O` seguida por um espaço e, em seguida, um traço.
A opção `O` é geralmente usada para especificar um arquivo onde a saída deve ser salva, mas quando usada com um traço, a saída vai para o `stdout`.
Finalmente, especificamos o URL do feed RSS do HPR.
16 Conteúdo do Documento XML
Isso nos fornece o documento XML RSS do HPR.
Há aproximadamente 5.000 linhas neste documento RSS.
A maior parte dessas linhas são as anotações do programa, que também estão incluídas no feed.
17 Extraindo os URLs dos Episódios do Podcast
Apenas 10 linhas do documento contêm as informações que nos interessam.
Estas linhas estão contidas em "tags XML" de "encerramento".
Nós apenas precisamos encontrar essas linhas e separar as URLs.
18 Ferramentas de Linha de Comando Padrão
Existem duas maneiras de fazer isso.
Uma é usar uma combinação de grep, sed e cut.
O grep pode encontrar as linhas que contêm as tags de fechamento.
O sed e o cut podem extrair o URL dos dados extras circundantes.
19
No entanto, este método não diferencia entre as tags de fechamento reais na parte de dados do feed RSS e as tags de fechamento nas notas do programa, que são incluídas no feed de episódios como este.
Isso pode ser um problema aceitável em termos práticos, mas podemos fazer melhor.
20 Utilizando um Analisador XML
O outro método é, na verdade, analisar o documento XML.
Existem, pelo menos, dois analisadores de linha de comando XML que eu conheço.
Estes são "xmllint" e "xlmstarlet".
Eu utilizei o xmllint neste exemplo.
Eu não usei o xmlstarlet, então não posso oferecer nenhum comentário sobre quão fácil ou difícil é usá-lo.
21
Eu não vou dar uma explicação detalhada de todas as coisas que o xmllint pode fazer.
Ele tem muitas funcionalidades, a maioria das quais, como o nome sugere, tem a ver com encontrar problemas de formatação no XML em si.
Descrever tudo o que ele pode fazer seria, pelo menos, um episódio por si só.
Em vez disso, eu simplesmente fornecerei o comando específico usado e explicarei cada elemento dele.
22
Neste exemplo, assumamos que estamos redirecionando a saída do wget diretamente para o xmllint.
O comando completo é:
`xmllint --xpath "//channel/item/enclosure/@url" - | cut -d'"' -f2`
23
Neste exemplo,
`xmllint` é o nome do comando.
`--xpath` informa que ele deve analisar o documento de acordo com a string que segue.
`"//channel/item/enclosure/@url"` informa que ele deve encontrar uma série de tags na hierarquia de channel, seguido por item, seguido por enclosure, e então extrair o atributo url da tag enclosure.
O "-" que segue indica que ele deve procurar a entrada do stdin em vez de um arquivo.
24
O resultado é uma string que tem o nome do atributo de URL, um sinal de igual, e a URL que queremos, entre aspas.
Para obter apenas a URL em si, encaminhamos a saída de xmllint para cut, usando os caracteres de delimitador "doublequote".
Em seguida, salvamos o resultado em um arquivo temporário.
Encontrando os novos episódios (25)
O próximo passo é encontrar os novos episódios do podcast.
Cada episódio do HPR é identificado por um URL único.
Isso significa que, se salvarmos os URLs dos episódios que já baixamos, apenas precisamos procurar por URLs que não estejam nessa lista salva.
O texto fornecido é um link para um arquivo de áudio, não um texto jornalístico. Portanto, não há uma tradução para o português brasileiro neste caso.
26
A maneira mais fácil de fazer isso é tomar nossas duas listas de URLs, ordená-las em arquivos temporários e, em seguida, comparar as URLs ordenadas usando o comando "comm".
27
Isto é simples, mas tem um inconveniente.
Alguns podcasts ocasionalmente mudam de distribuidores.
Quando fazem isso, os antigos podcasts são republicados com novos URLs e você acaba baixando de novo muitos episódios antigos.
28
Com o HPR, poderíamos contornar isso extraindo apenas o nome do arquivo e procurando por ele em vez do URL completo.
No entanto, deixarei esse problema como um exercício para o aluno e simplesmente aceito que, se o formato da URL mudar, podemos acabar baixando os episódios antigos de novo.
Como o feed tem um máximo de apenas 10 episódios, isso não é realmente um grande problema.
Seria mais um problema com podcasts que têm um número muito grande de episódios em seu feed, mas as soluções para esses casos serão específicas do feed.
29 Baixando os Novos Podcasts
Agora deveríamos ter uma lista de URLs para os novos podcasts que ainda não temos.
Normalmente, isso deve ser apenas um arquivo, mas podem ser vários, ou até 10, se não ligamos nosso computador há muito tempo.
Portanto, precisamos iterar pelo arquivo de URLs de novos podcasts e baixar cada uma delas.
30
Antes de fazer isso, porém, devemos verificar se há, de fato, algo novo para baixar.
Para fazer isso, use simplesmente "wc -l" para contar o número de linhas na lista de novas URLs e salve o número resultante.
31
Se esse número for zero, não há nada para baixar, podemos pular o passo de download.
Como verificação adicional, devemos verificar se o número de downloads excede um valor de limiar que desejamos definir.
Isso não é um problema significativo com o HPR, mas alguns podcasts têm centenas de arquivos em seu feed RSS, em vez apenas dos mais recentes.
Se excedermos o limite de download, então precisamos registrar um erro e pular o download.
32
Assumindo que não haja problemas até agora, a primeira coisa que precisamos fazer é extrair o nome do arquivo de áudio da URL.
Podemos fazer isso usando o comando "basename".
Usaremos isso para especificar o nome que utilizamos ao salvar o arquivo de áudio.
33
O HPR tem um nome de arquivo muito bem formatado.
Alguns podcasts não têm, e para esses, você precisaria construir um nome adequado, seja usando informações encontradas na URL ou simplesmente criando um nome usando um carimbo de data/hora.
34
Em seguida, baixamos o arquivo de áudio usando o wget.
Isso é semelhante ao modo como baixamos o feed RSS, mas com algumas mudanças.
Uma é que aumentei o tempo limite para 90 segundos.
Isso pode não ter sido necessário, mas pareceu uma boa ideia.
35
O próximo passo é que, ao especificar o nome do arquivo de saída usando -O, utilizamos o nome do arquivo extraído da URL.
O terceiro ponto é que especificamos um diretório de destino usando a opção -P.
36
Após o wget terminar, incluindo quaisquer tentativas de repetição que ele precisou fazer, verificamos em seguida que o novo arquivo esperado esteja presente e não esteja vazio.
Fizemos isso usando uma declaração "if" com a opção "-s".
Se o arquivo for encontrado e não for nulo, adicionamos esse URL a uma lista temporária de URLs baixadas.
37
Se o arquivo não estiver presente ou tiver comprimento zero, registramos uma mensagem de erro em um log de erros.
Volto a esse ponto mais tarde.
38
Em seguida, se houver mais de um podcast para baixar, pausamos por 3 segundos.
Embora não seja estritamente necessário, é considerado "educado" não bombardear um servidor repetidamente, mas sim inserir uma pequena demora entre os downloads de arquivos.
39
Após baixar todos os arquivos de áudio da nossa lista, podemos adicionar a lista de URLs dos arquivos baixados à lista permanente.
Enquanto estamos nisso, devemos usar "tail" para aparar o log permanente para evitar que ele cresça indefinidamente.
Esse limite deve ser várias vezes maior que o número de arquivos no feed RSS.
Selecionei 50 neste caso.
40
Finalmente, escrevemos quaisquer erros no log de erro permanente, e também escrevemos esses mesmos erros em outro arquivo usado para sinalizar erros para exibição ao usuário.
Agora temos um podcast HPR baixado com sucesso, pelo menos.
Notificar o Usuário de Eventos 41
Seria conveniente ser informado sobre novos downloads de podcasts quando ocorrerem, e também ser notificado de quaisquer erros.
Uma das limitações das tarefas cron é que elas não podem acessar a interface do usuário.
Isso significa que não podemos enviar facilmente uma mensagem diretamente ao sistema de notificação para informar o usuário sobre a presença de novos podcasts ou de erros.
42 inotifywait
A solução para isso é usar o "inotifywait" para monitorar arquivos e diretórios específicos em busca de mudanças.
A página de manual do inotifywait afirma o seguinte:
43
O inotifywait espera de forma eficiente por mudanças em arquivos utilizando a interface inotify(7) do Linux. É adequado para esperar por mudanças em arquivos a partir de scripts de shell. Ele pode sair assim que um evento ocorrer ou executar continuamente e sair os eventos conforme eles acontecem.
Fim da citação.
44
Em muitas distribuições Linux, o inotifywait é fornecido pelo pacote "inotify-tools".
Não vou detalhar todas as funcionalidades do inotifywait.
Em vez disso, vou apenas descrever como usá-lo para nossos propósitos aqui.
45 Modos do inotifywait
Devo apontar, em primeiro lugar, que o inotifywait opera em dois modos diferentes.
No modo padrão, ele sai após ser acionado por um evento e deve ser reestabelecido novamente para continuar monitorando.
No modo monitor, ativado pela opção "-m", ele roda indefinidamente, respondendo aos eventos.
Usarei o modo padrão aqui.
46
A página de manual do inotifywait oferece um exemplo simples que poderíamos copiar e modificar para nossos fins.
Um grande número de exemplos que você encontrará se baseia nesse exemplo.
No entanto, ele não faz exatamente o que queremos, então precisamos mudar algumas coisas.
47 podfetchnotify
O primeiro script de shell é aquele que monitora a chegada de novos podcasts e envia uma notificação ao usuário.
Vou chamar isso de "podfetchnotify".
Os scripts completos estão nas notas do show, vou fornecer apenas uma breve descrição aqui.
Configurando 48 Relógios de Eventos Usando inotifywait
O script está encapsulado em um loop while que roda indefinidamente.
Na primeira linha dentro do loop while, chamamos o inotifywait.
O inotifywait então bloqueia até que o evento que ele é instruído a procurar ocorra.
Em resumo, a execução do script esperará lá até que um evento ocorra.
49
Os nomes dos eventos estão listados no arquivo principal.
Neste caso, estamos procurando por "modificar", "criar" e "mover_para".
Cada um desses faz mais ou menos o que você esperaria, reagindo à modificação de um arquivo existente, criação de um novo arquivo ou movimentação de um arquivo para esse diretório.
50 Problemas Ao Testar Usando Editores de Texto
Devo observar que, se você estiver testando um script que usa inotifywait, modificar um arquivo com um editor de texto pode não produzir os resultados que você espera.
Em vez disso, ele trata isso como um novo arquivo com o mesmo nome, apagando o arquivo original.
Como inotifywait se anexa ao inode em vez do nome do arquivo, ele vê o arquivo que o editor de texto modificou como um novo arquivo.
Se você quiser testar isso de forma realista, use "echo" para sobrescrever o arquivo usando redirecionamento de I/O.
Capturando a saída
No meu exemplo, eu capturo a saída da saída padrão em uma variável, mas não faço nada com ela.
Se você quiser, por exemplo, exibir o nome do arquivo de podcast recém-baixado, utilize a opção --format junto com um código de formatação apropriado.
Há detalhes sobre isso na página do manual.
Na próxima linha, capturamos o código de saída usando "$?".
Respondendo aos códigos de saída
Se o código de saída for zero, então um evento monitorado foi acionado e deve haver um novo podcast no diretório.
Neste caso, exibimos uma mensagem indicando que um novo podcast chegou.
Eu descreverei brevemente como enviar notificações.
Se o código de saída não for zero, então ocorreu um erro.
Um exemplo desse erro seria se o diretório não estivesse presente quando o monitoramento foi iniciado.
Neste caso, exibimos uma mensagem indicando que um erro fatal ocorreu e depois saímos.
53 Atraso para Mais Podcasts
Finalmente, usamos "sleep" para esperar um período de tempo arbitrário para evitar que notificações sejam acionadas várias vezes se vários podcasts fossem baixados em sucessão.
Neste caso, escolhi esperar 60 segundos.
54
Agora completamos o processo e podemos retornar ao topo do loop e retomar a espera usando inotifywait.
Enviando notificações ao usuário
Mencionei acima o envio de mensagens de notificação ao usuário.
No ambiente de desktop Gnome, as mensagens de notificação aparecem do centro da barra superior em uma lista.
Outros desktops ou sistemas operacionais podem ter algo semelhante.
56
Para enviar uma mensagem de notificação para a área de notificação, você usa o comando "notify-send".
Basta seguir o "notify-send" com uma string entre aspas e ela será exibida na área de notificação.
57 podfetcherrornotify
O segundo script de shell é aquele que notifica o usuário sobre erros.
Vou chamar isso de "podfetcherrornotify".
Com este script de shell, configuramos uma vigilância em um arquivo que contém quaisquer mensagens de erro do podfetch.
Este script é muito semelhante ao podfetchnotify.
58
As exceções são:
Com inotifywait, monitoramos apenas para "modificar".
Não há um comando sleep no final do loop.
Em vez disso, dormimos por alguns segundos logo após obter o código de saída do inotifywait.
Isso ajuda a prevenir problemas causados por condições de corrida.
59
Em seguida, verificamos o código de saída do inotifywait.
Se for zero, lemos o arquivo de relatório de erro e enviamos uma mensagem de notificação ao usuário contendo a mensagem de erro.
60
Se não for zero, verificamos se o diretório que deveria conter o log de erro existe.
Se não existir, enviamos uma mensagem de notificação ao usuário nesse sentido e terminamos o script.
61
Se o diretório existir, verificamos se o arquivo de mensagem de erro usado para sinalizar existe.
Se o arquivo não existir, criamos ele.
62
Um dos motivos para um erro inotifywait é que, se o arquivo que ele é orientado a monitorar não existir, ele não pode configurar uma condição de observação.
Ao criar o arquivo, corrigimos a causa do erro e permitimos que o inotifywait funcione normalmente.
63
Finalmente, incrementamos um contador de erros e verificamos se o limite foi excedido.
Se houver erros excessivos, envie uma mensagem de notificação ao usuário e saia.
O motivo disso é dar ao usuário uma indicação de que as notificações de erro não estão funcionando por algum motivo e pode haver um problema que precisa ser investigado.
64
O contador de erros é resetado sempre que o status de saída do inotifywait for ok, então glitches inesperados ocasionais devem ser ignorados.
Claro, erros na busca de podcasts são algo que provavelmente acontecerá apenas raramente, se é que acontecerá, então esta etapa final pode ser vista como um embelezamento desnecessário.
Instalando os Scripts
A seguir, descreverei como instalar e preparar os scripts para execução.
Precisamos seguir os seguintes passos.
66
Primeiro, precisamos criar um diretório para armazenar os scripts e seus arquivos de dados associados.
Em seguida, precisamos criar um diretório para armazenar os podcasts baixados.
Então, devemos copiar os scripts para esses diretórios e torná-los executáveis.
Em seguida, devemos editar os scripts para que o caminho do arquivo no script corresponda às localizações dos novos diretórios que criamos.
67
Então precisamos instalar o xmllint, ou, alternativamente, modificar o script de download para comentar o uso do xmllint e habilitar o método alternativo usando grep e sed em vez disso.
Então precisamos executar cada script manualmente da linha de comando para verificar erros.
Se o podfetch foi executado corretamente, ele deve baixar os 10 podcasts mais recentes durante este teste.
Adicionar o podfetch ao Crontab.
Isso descreve como executar os scripts manualmente.
Para buscar podcasts automaticamente, precisamos adicionar o script podfetch à agenda cron.
Para fazer isso, abra um terminal.
69
Digite "crontab -e" e pressione Enter.
Um editor de texto deve abrir contendo o arquivo crontab.
No Ubuntu, esse editor é o GNU nano.
Insira os parâmetros cron apropriados.
Fornecerei um exemplo aqui para executá-lo 12 minutos após a hora a cada três horas.
70
12/03/**** /home/usuário/caminho_de_arquivos/podfetch.sh
71
Eu não vou explicar o cron em detalhes aqui.
O exemplo que eu acabei de dar deve ser suficiente para a maioria das pessoas.
O parâmetro "*/3" fará com que ele execute a cada três horas.
O parâmetro "12" fará com que ele funcione 12 minutos após a hora quando realmente for executado.
72
Verificar a cada três horas deve ser suficiente para a maioria das pessoas, mas você pode ajustar conforme necessário.
Eu recomendaria, no entanto, que você não verifique com mais frequência do que uma vez por hora.
Verificar com mais frequência do que o necessário sobrecarrega os servidores de distribuição.
É muito improvável que você realmente precise de cada novo episódio assim que estiver disponível.
73
Eu também recomendaria mudar o parâmetro "12" para algum outro valor aleatório de minutos.
Sugiro evitar em pontos cheios, como no horário ou a cada meia hora, pois muitas outras pessoas provavelmente estão verificando nesses momentos, e seria melhor espalhar a carga de forma mais uniforme ao longo do tempo.
74
O parâmetro de caminho de arquivo, claro, deve corresponder ao caminho real onde você localizou o script, incluindo o nome de usuário correto.
75: Fazendo com que os Scripts de Notificação Iniciem Automaticamente
Os dois scripts de notificação podem ser configurados para iniciar automaticamente.
O método exato para fazer isso pode variar de acordo com a distribuição ou o desktop.
76
No Ubuntu, isso é feito usando o programa de interface gráfica de preferências de aplicativos de inicialização, que deve vir pré-instalado.
77
Não vou entrar em detalhes sobre isso aqui, é bastante evidente como usá-lo uma vez que você o vê.
O que este programa faz é criar arquivos ".desktop" no diretório ".config/autostart" em seu diretório doméstico.
78
Esses arquivos ".desktop" são todos executados automaticamente na inicialização.
Uma vez que você tenha adicionado os scripts de notificação, precisará fazer logout e depois logar novamente para torná-los ativos.
79 Conclusão
Neste episódio, expliquei como escrever um conjunto de simples scripts de shell para baixar automaticamente cada novo episódio do HPR assim que for lançado e notificá-lo de sua chegada.
80
O script de download descrito aqui é adaptado especificamente para uso com o HPR apenas.
No entanto, ele foi derivado de um script maior que baixava outros podcasts também, com base em informações lidas de um arquivo de texto.
Se você estiver se sentindo ambicioso, pode adicionar essas funcionalidades de volta a isso para lidar com todos os podcasts que você ouve.
81
Em um comentário para outro episódio do HPR, eu disse que abordaria as tags ID3 em arquivos MP3, mas este episódio já é longo o suficiente, então vou deixar esse assunto para depois.
Aguardo ansiosamente por nos encontrarmos novamente em outro episódio do Hack Public Radio.
# ======================================================================
podfetchdownloader
¡#!/bin/bash
# Buscar podcasts pendentes do HPR listados no feed RSS do HPR.
# 8-Jun-2026
# Licenciado sob GPLv3 ou posterior.
# ======================================================================
Hoje, data e hora no formato YYYYMMDDHHMMSS.
timestamp_do_podcast=$( data + "%Y%m%d%H%M%S" )
# O caminho absoluto até o script. Isso é necessário quando ele é executado.
# Utilizando um trabalho cron.
caminho_de_acesso="/home/eu/Aplicativos/hprfetch"
# Este é o caminho absoluto para onde armazenar os arquivos do podcast.
caminho_de_arquivo_de_pod=" /home/eu/Música/Podcasts/HPR"
# Crie os nomes completos dos caminhos aqui para todos os arquivos de texto utilizados.
podcastsfetched = "$podpath/podcastsfetched.txt"
poderrorslog = "$podpath/poderrorslog.txt"
poderrorsreport = "$podpath/poderrorsreport.txt"
tmpoldurlssorted = "$podpath/tmpoldurlssorted.txt"
tmppodsnew = "$podpath/tmppodsnew.txt"
tmppodstodownload = "$podpath/tmppodstodownload.txt"
tmppodserrors = "$podpath/tmppodserrors.txt"
tmppodcastsfetched = "$podpath/tmppodcastsfetched.txt"
tmplog = "$caminho/do/arquivo/tmplog.txt"
# O URL para o feed RSS do HPR.
URL: "http://hackerpublicradio.org/hpr_rss.php"
# Limite no número de podcasts para download.
Limite de download = 11
# Nome do podcast.
Nome do Pod: "Hacker Public Radio"
# ======================================================================
# Verifique se os caminhos obrigatórios existem.
Se este caminho não existir, não é possível registrar o erro.
Se [[ ! -d "$podpath/" ]]; então
echo "$podttimestamp Erro - Não foi possível encontrar $podfilepath."
exit 1
fi
# Onde armazenar o arquivo do podcast baixado.
Se [[ ! -d "$podfilepath/" ]]; então
echo "$podttimestamp Erro - Não foi possível encontrar $podfilepath." >> $tmppodserrors
Copie o log de erros do arquivo temporário de erros para os arquivos permanentes.
LogErrors
Saia com código 1
fi
# ======================================================================
# Verifique se o log de podcast existe. Leem-no antes de escrever nele,
# então ele deve existir, ou ficaremos pendurados por não estar presente.
Se [[ ! -e $podcastsfetched ]]; então
touch $podcastsfetched
Seja para informar, entreter ou debater, o jornalismo é a espinha dorsal da comunicação democrática.
# ======================================================================
# Exclua os arquivos especificados se eles existirem.
# Esta função aceita múltiplos nomes de arquivos em um número variável de parâmetros.
LimparArquivos()
{
# $@ aceita múltiplos parâmetros.
Para f em "$@"; faça
# Verifique se o arquivo existe.
Se [ -e "$f" ]; então
Remova "$f"
Arquivo de configuração
Concluído
}
# ======================================================================
# Copie o log de erros do arquivo temporário de erros para os arquivos permanentes.
Função LogErrors() {
Se [ -e $tmppodserrors ]; então
# O log permanente.
cat $tmppodserrors >> $poderrorslog
Este arquivo é monitorado para exibição por outros scripts.
Redireciona os erros temporários para um relatório.
Fim do comando.
}
# ======================================================================
# Obtém os dados de URL de um feed RSS
ObterDadosURLRSS() {
Baixar o conteúdo do feed com tempo limite de 20 segundos e 3 tentativas, salvando em um arquivo temporário.
| Analisar o XML e extrair os URLs dos anexos dos itens do canal.
| Ordenar os resultados e salvar em um arquivo temporário.
# Esta é uma metodologia alternativa que não utiliza xmllint.
# No entanto, ela não é tão robusta. Se alguém incluísse o
# primeiro padrão de pesquisa grep em suas anotações do programa, então
# ele procuraria isso como uma tag válida e sairia com o seguinte texto
# como um URL.
#wget --timeout=20 --tries=3 -O - "$PodURL" | grep "<enclosure url="
| sed -n 's/^.*enclosure//p' | sed -n 's/^.*url=//p'
| cut -d'"' -f2 | sort > $tmppodsnew
}
# ======================================================================
Descubra quais podcasts ainda não temos.
Encontre novos podcasts ()
Cat $podcastsfetched | sort > $tmpoldurlssorted
Compreensão -13 $tmpoldurlssorted $tmppodsnew > $tmppodstodownload
Remova $tmpoldurlssorted
}
# ======================================================================
Baixe os podcasts.
BaixarPodcasts()
Limpe a lista temporária anterior de podcasts baixados.
Verdadeiro > $tmppodcastsfetched
Para cada i em $(cat $tmppodstodownload)
Faça
# Extraia o nome do arquivo da URL.
fname=$(basename $i)
outputpodname="$podfilepath/$fname"
# Baixe o arquivo.
wget --timeout=90 --tries=3 -P $podfilepath $i -O "$outputpodname"
Verifique se o arquivo existe e não está vazio.
Se [[ -s "$outputpodname" ]]; então
Escreva $i >> $tmppodcastsfetched
Caso contrário
Escreva "$podttimestamp Erro - $outputpodname não foi encontrado ou está vazio." >> $tmppodserrors
fim se
# Aguarde um tempo razoável entre vários downloads.
Se (( $PodCount > 1 )); então
Durma por 3 horas.
Finalizado.
Feito.
Adicione a lista de arquivos baixados ao log.
Verifique se a lista existe e não está vazia.
Se o arquivo temporário de podcasts baixados não estiver vazio:
Adicione o conteúdo do arquivo temporário ao arquivo de podcasts baixados.
Limpe o arquivo de log para evitar seu crescimento infinito.
`tail -n50 $podcastsfetched > $tmplog`
Mova $tmplog para $podcastsfetched
fi
# Remova o arquivo temporário agora que terminamos de usá-lo.
Remover $tmppodcastsfetched
}
# ======================================================================
# Limpe quaisquer arquivos remanescentes.
Limpeza de arquivos "$tmppodsnew" "$tmppodstodownload" "$tmppodserrors" "$tmppodcastsfetched"
# Obtenha os dados RSS.
Obtenha os dados da URL do RSS
Descubra quais podcasts são novos.
Encontre novos podcasts.
Conte quantos podcasts novos há.
`PodCount=$( cat $tmppodstodownload | wc -l )`
Se não houver podcasts para baixar, pule este passo.
Se houver muitos podcasts para este feed, registre um erro e pule.
Este erro continuará a acontecer até que algo seja feito a respeito.
Se ($PodCount > 0)
Se ($PodCount > $DownloadLimit)
Echo "$podttimestamp: Demasiados podcasts para $PodName: $PodCount." >> $tmppodserrors
Caso contrário
# Baixar os podcasts listados no arquivo temporário.
DownloadPodcasts
Fim se
Fim se
# ======================================================================
Copie o log de erros do arquivo temporário de erros para os arquivos permanentes.
LogErrors
# Limpe os arquivos temporários.
CleanupFiles "$tmppodsnew" "$tmppodstodownload" "$tmppodserrors" "$tmppodcastsfetched"
# ======================================================================
FIM DO PRIMEIRO SCRIPT SHELL
INÍCIO DO SEGUNDO SCRIPT SHELL
podfetchnotify
#!/bin/bash
Parte do Podfetch.
Monitora a aparição de novos arquivos no diretório de podcasts novos.
Deve ser executado como uma tarefa em segundo plano.
Instale-o utilizando a utilidade "Aplicativos de Inicialização" no Ubuntu.
# ======================================================================
Caminho onde os novos podcasts serão armazenados.
`podfilepath="/home/me/Música/Podcasts/HPR"`
# ======================================================================
Aguarda a modificação do diretório de podcasts.
enquanto verdadeiro; faça
Verifique novos arquivos.
Atribua a mensagem de erro $(inotifywait -e modificar -e criar -e movido_para $podfilepath)
Atribua o resultado a uma variável.
Verifique se o término ocorreu devido a um novo podcast ou a um erro.
Se o resultado for igual a 0, então:
Sucesso, sinalize um novo podcast.
Envie uma notificação: "Novo podcast HPR disponível."
Caso contrário,
Verifique se o diretório existe.
Se não existir, não há muito o que podemos fazer para consertá-lo.
Se `[ ! -e "$poderrorspath" ]`; então
Envie uma notificação: "Erro de Podfetch: Diretório de Podcast não encontrado $poderrorspath"
Sair com código 1
fi
fi
Espere um pouco para que múltiplos novos arquivos não reativem a notificação repetidamente.
durma 60
feito
# ======================================================================
FIM DO SCRIPT DE CONSOLAÇÃO II
INÍCIO DO SCRIPT DE CONSOLAÇÃO III
erro de busca de podcast
Criado na terça-feira, 23 de junho de 2026
#!/bin/bash
# Parte do Podfetch
Este monitora o arquivo de relatório de erros do Podfetch para novos erros.
Isso deve ser executado como uma tarefa em segundo plano.
Instale-o usando a utilidade "Aplicativos de Inicialização" no Ubuntu.
# ======================================================================
Onde o arquivo de relatório de erros do programa Podfetch está localizado.
`poderrorspath="/home/me/Apps/hprfetch"`
A rota completa e o nome do arquivo.
`poderrorsreport="$poderrorspath/poderrorsreport.txt"`
# ======================================================================
Contador de erros.
contador_de_erros = 0
Aguarde a modificação do arquivo "poderrorsreport".
Enquanto for verdadeiro; faça
msg_de_erro=$(inotifywait -e modificação $poderrorsreport)
resultado=$?
# Aguarde um pouco para garantir que a escrita no arquivo esteja completa.
dorme 3
se ((resultado == 0)); então
Obtenha a última mensagem de erro.
Remova o carimbo de data no início da linha e pegue o restante.
poderr=$( tail -n $poderrorsreport | cut -d" " -f2- )
Envie uma notificação: "Erro Podfetch: $poderr"
Reinicie o contador de erros sempre que houver um resultado bem-sucedido.
errcount=0
Caso contrário:
Verifique se o diretório existe.
Se [ ! -e "$poderrorspath" ]; então
Enviar notificação: "Erro de Podfetch: caminho do relatório de erro não encontrado $poderrorspath"
Sair 1
fi
# Verificar se o arquivo que estamos tentando monitorar existe.
# Se não, criar um arquivo vazio para sinalizar erros.
Se [ ! -e "$poderrorsreport" ]; então
echo > $poderrorsreport
Aumente o contador de erros.
# Aumente o contador de erros.
count=$(( count + 1 ))
Se (count > 3); então
Envie uma notificação: "Erro Podfetch: Erros desconhecidos excessivos, saindo."
Sair 1
fi
fi
Forneça
# ======================================================================