Pour mon usage personnel j’ai intégré ces commandes dans des scripts afin d’y ajouter quelques fonctionnalités.

Le script de démarrage que j’ai nommé wakeonlan.sh (original) prend en paramètre l’adresse MAC et l’adresse IP de la machine à réveiller et permet de faire n essais de réveil espacés de m secondes avant de rendre la main.

#!/bin/bash
# Wake up remote machine
# Usage: $0 mac_adress ip_adress
 
# Check interval
SLEEPTIME=60
# Temp directory where to store a file to indicate that the computer was already turn on (used for shutdow)
TEMP_DIRECTORY=/$HOME/tmp
# Number of retries
RETRY=20
 
die () {
 echo >&2 "$@"
 exit 1
}
 
[ "$#" -eq 2 ] || die "Usage : $0 Mac_adress IP_adress"
HOST_MAC=$1
HOST_IP=$2
 
[ -d $directory ] || mkdir $directory
 
ping -c 2 -w 15 $HOST_IP > /dev/null
RESULT=$?
if [ $RESULT -eq 0 ]; then
 echo "Host $HOST_IP is already up - exiting"
 touch $TEMP_DIRECTORY/$HOST_IP
 exit 0
else  
 echo "Trying to wake up $HOST_IP"
 TEST_NUMBER=0
 while [ $RESULT -ne 0 ]; do
  TEST_NUMBER=`expr $TEST_NUMBER + 1`
  echo "Test #$TEST_NUMBER)"
  wakeonlan $HOST_MAC
  sleep $SLEEPTIME
  ping -c 2 -w 15 $HOST_IP > /dev/null
  RESULT=$?
  if [ $RESULT -ne 0 ] && [ $TEST_NUMBER -eq $RETRY ]; then
   echo "$RETRY retry unsuccessful - leave"
   exit 1
  fi
 done
fi

On pourra remarquer que si la machine est déjà allumé, le script crée un fichier portant son adresse IP, ce fichier est utilisé par le script d’arrêt.

Pour fonctionner ce script à besoin du paquet wakeonlan.

Ce dernier nommé shutdown.sh (encore original) n’arrête l’ordinateur que si ce dernier n’était pas déjà allumé avant le wakeonlan (état connu par la présence au non du fichier nommé de l’adresse IP de la machine à réveiller / éteindre)

#!/bin/bash
# Shutdown a remote machine
# Usage: $0 user ip_adress
 
# Temp directory where to check a file that indicate if the computer doesn't need to shutdown (file created by wakeonlan script)
TEMP_DIRECTORY=$HOME/tmp
 
die () {
 echo >&2 "$@"
 exit 1
}
 
[ "$#" -eq 2 ] || die "Usage : $0 user IP_adress"
 USER=$1
 HOST_IP=$2
 
if [ -f $TEMP_DIRECTORY/$HOST_IP ]
then  
 echo "The host $HOST_IP was already turned on so we don't shutdown it"
 rm $TEMP_DIRECTORY/$HOST_IP
 exit 0
fi
 
echo "Shuting down $HOST_IP"
ssh $USER@$HOST_IP "sudo shutdown -h now"

Ce script prend en paramètre l’adresse IP de la machine à éteindre et l’utilisateur qui  lancera la commande shutdown via SSH.

La machine cible doit avoir sudo (toujours le cas sur Ubuntu) et la commande shutdown ne doit pas demander de mot de passe (paramétré dans le sudoer)

Image par tom.z sous CC BY-NY-SA

J’ai aussi installé logrotate sur mon serveur, outil qui permet de faire tourner et d’archiver les fichiers de logs

Pour que les 2 fonctionnent ensemble il faut ajouter une configuration dans logrotate pour qu’il prennent en compte NGINX, ce dernier n’étant pas reconnu par logrotate lors de son installation.

Il faut donc créer un fichier nginx sous /etc/logrotate.d/ et y coller ceci (à adapter) :

/var/log/nginx/*.log {
	#rotate the logfile(s) daily
	daily
	# adds extension like YYYYMMDD instead of simply adding a number
	dateext
	# If log file is missing, go on to next one without issuing an error msg
	missingok
	# Save logfiles for the last 10 days
	rotate 10
	# Old versions of log files are compressed with gzip
	compress
	# Postpone compression of the previous log file to the next rotation cycle
	delaycompress
	# Do not rotate the log if it is empty
	notifempty
	#after logfile is rotated and nginx.pid exists, send the USR1 signal
	postrotate
		[ ! -f /var/run/nginx.pid  ] || kill -USR1 `cat /var/run/nginx.pid`
	endscript
}

C’est la directive postrotate qui est spécifique à NGINX et qui est importante : une fois les log tournées / archivées on lance un signal d’arrêt à NGINX pour qu’il recrée les fichiers de logs.

On testera la configuration avec la commande :

sudo logrotate -d /etc/logrotate.d/nginx

Voila pour le paramétrage de base.

J’y ai personnellement ajouté l’appel à un script de mon crû avant que logrotate ne fasse tourner les logs.

Ce script analyse les logs d’accès de NGINX et effectue une petite analyse des IPs et des utilisateurs qui se connectent :

#!/bin/bash
cd $(dirname "${0}")
log=[nom et chemin du fichier log]
 
date > $log
echo -e "\n"  >> $log
 
for file in /var/log/nginx/*access.log
do
     echo ${file} >> $log
 
     echo -e "\nNb accès par IP" >> $log
     cat ${file} | awk '{print $1}' | sort | uniq -c  >> $log
     sed -i 's/\(81..125.231.15$\)/\1 : Travail/' $log
     sed -i 's/\(89.5.45.52$\)/\1 : Maison/'  $log
 
     echo -e "\nNb accès par utilisateur" >> $log
     cat ${file} | awk '{print $3}' | sort | uniq -c >> $log
 
     echo -e "\n-------------------------\n" >> $log
done

qui produit ce genre de rapport :

jeudi 14 avril 2011, 13:35:21 (UTC+0200)
 
/var/log/nginx/access.log
 
Nb accès par IP
1 121.162.199.215
6 192.168.1.100 : Maison
1 208.80.194.29
1 222.187.222.26
 
Nb accès par utilisateur
4 -
5 mon_utilisateur
 
-------------------------
/var/log/nginx/xxxx.access.log
 
Nb accès par IP
250 125.54.42.12
 
Nb accès par utilisateur
250 utilisateur2
-------------------------
/var/log/nginx/yyyy.access.log
Nb accès par IP
Nb accès par utilisateur
-------------------------

Pour prendre en compte ce script et le faire exécuter j’ai ajouté les directives suivantes au fichier nginx de logrotate  :

# scripts are runned only once
sharedscripts
 
# before rotation log are analyzed
prerotate
    /chemin/statistiques_nginx.sh
endscript

Ainsi avant de faire tourner les logs NGINX logrotate exécute une seule fois le script que j’ai nommé statistiques_nginx.sh. Ce dernier produit un rapport que je m’envoie par email (via un autre script)

A noter qu’il existe des solutions clé en main et beaucoup plus évoluées, complètes d’analyse et de statistiques pour les logs des serveurs Web (voir dans les sources), mais cela me semble un peu trop pour mon usage.

Sources :

Logrotate :

• nginx logrotate config
• nginx log rotation
• How To Configure Logrotate Nginx Log in FreeBSD and Linux Machine.

Autres solutions de rotation des logs :

• Proper way to rotate Nginx logs
• Nginx and Cronolog

Script analyse des logs :

• HOWTO sort web-server logs to find top users
• Shell Script List All Top IP Address Accessing Apache / Lighttpd

Analyse des logs plus évoluées :

• Analysis access logs of Nginx by awstats
• nginx log rotation and analysis with webalizer
• w3perl
• awstats

Transmission supporte évidemment les blocklists, mais la liste utilisée n’est pas paramétrable, Transmission télécharge une liste de niveau 1 sur son URL mirroir

De plus la mise à jour de la liste n’est pas automatique. Sur le client lourd (transmission GTK) il existe un bouton permettant de mettre à jour la liste, mais évidemment sur le démon il n’ya pas de bouton.

Nous allons donc voir comment dans un premier temps mettre à jour la liste lorsque l’on utilise le démon puis ensuite comment utiliser des listes personnalisées et les mettre à jour automatiquement…

Dans les 2 cas il faut que le paramètre blocklist-enabled soit positionné à true dans votre fichier settings.json

Pour mettre à jour la liste de blocage Transmission lorsqu’on utilise le démon il faut passer par le commande transmission-remote du paquet transmission-cli :

#! /bin/sh
username='username'
password='password'
transmission-remote --auth $username:$password --blocklist-update
sudo /etc/init.d/transmission-daemon restart

A la fin on re-démarre le démon pour qu’il prenne ne compte la nouvelle liste, si comme moi vous utilisez sudo et que vous exécutez ce script avec votre utilisateur il faudra autoriser la commande de re-démarrage dans votre sudoer (voir en fin de éème solution)

Il suffira alors de mettre ce script dans une tache cron et le tour est joué…

Rque : comme ce script contient les login et mot de passe en clair de transmission RPC il conviendra de restreindre ses droits d’accès (chmod 700 script.sh)

Je n’ai pas testé ce script puisque j’utilise la deuxième solution qui consiste à gérer la mise à jour et l’origine de la liste de blocage :

#!/bin/bash
# Télécharge des blockslist à partir de http://iblocklist.com/lists.php
# et les intégre dans le répertoire de Transmission
# répertoire de travail
 
# répertoire de travail / temporaire
travail=$HOME/tmp/blocklists
# réperoire où Transmission stock les fichiers blocklist
transmissionBlocklist=$HOME/.config/transmission-daemon/blocklists
 
echo -e "******** Compilation d'une Bloclist pour Transmissionbt ***********"
 
if [ -e $travail ]; then
    echo -e "Répertoire de travail $travail "
else
    mkdir $travail
fi
rm $travail/*
 
#récupération des fichiers http://iblocklist.com/lists.php
echo -e "\n********* Téléchargements des listes de blocage *******************"
wget http://list.iblocklist.com/?list=bt_level1 -O $travail/bt_level1.gz
wget http://list.iblocklist.com/?list=bt_level2 -O $travail/bt_level2.gz
 
#décompression
echo -e "\n********* Décompression des listes téléchargées *******************"
gunzip -v $travail/*.gz
 
#concaténer les fichiers
echo -e "\n********* Création d'une seule liste sans redondance des données **"
echo -e "traitement en cours ...Patientez SVP..."
cd $travail
list1=$(ls) && sort -u $list1 >> blocklist &&
cd -
 
#Déplacement du fichier blocklist dans le répertoire de Transmission
echo -e "\n********* Déplacement de la Blocklist *****************************"
if [ -d $transmissionBlocklist ] ;then
    echo -e "Copie de sauvegarde de l'ancien fichier"
    mv -f $transmissionBlocklist/blocklist $travail/blocklist.bak
    echo -e "Déplacement du nouveau fichier dans le répertoire de Transmission"
    mv -f $travail/blocklist $transmissionBlocklist
fi
 
# Rechargement de Transmission
echo -e "Rechargement de la configuration de Transmission"
sudo /etc/init.d/transmission-deamon reload
ls $transmissionBlocklist/blocklist > /dev/null 2>&1
if [ $? -eq 0 ]; then
    echo -e "\n*********** Opération terminée ************************************"
else
    echo -e "\n *** KO **** !! Le fichier bloklist est vide !! *** KO *** "
fi

Le script télécharge les listes voulues (ici les niveaux 1 et 2), les dézippe et les concatène en excluant les doublons, la liste résultante est ensuite copié dans le répertoire utilisé par Transmission et le démon est rechargé.

Comme indiqué précédemment pour que la commande de rechargement du démon puisse être exécuté via sudo sans demande de mot de passe il faut modifier le sudoer ce qui se fait en lançant la commande

sudo visudo

Et en ajoutant une ligne du type :

mon_utilisateur ALL= NOPASSWD: /etc/init.d/transmission-daemon

De même que pour la première solution on mettra ce script dans une tache cron (à la semaine par exemple)

Pour finir quelques mots sur les listes de blocage.

Transmission supporte les formats P2P Plaintext (Nom:IP_Début:IP_Fin) et DAT (format binaire non éditable)

On pourra trouver des listes de blocage P2P sur les sites suivants :

• http://tbg.iblocklist.com/
• http://iblocklist.com/

On recommande la liste de iblocklist de niveau 1 (IP impliqués dans la lutte contre le piratage)  en général et la liste de niveau 2 (IP des sociétés en général, des laboratoires et proxy) éventuellement.

Edit : 31/05/2011 : correction la variable d’environnement $USER n’est pas connu dans CRON, utilisation de $HOME à la place (mieux en plus)

Sources :

• Papillon-butineur: Blocklists avec Transmission : source du script initial que j’ai modifié
• Blocklists – Transmission : documentation officielle sur les blocklist
• Scripts/BlockListUpdater – Transmission : script de mise à jour des blocklist (beaucoup moins évolué que celui de papillon-butineur)
• Random Stuff: Automatically update Transmission’s block list : Script moins complet
• transmission-remote and blocklist-update : script pour mettre à jour la blocklist

Image par Lou Ect sous CC BY-NC-ND

Dans le cadre de la sortie de Lucid Lynx (Ubuntu 10.04), je vais (oui je sais je suis en retard) ré-installer complétement mon système, puisqu’à cette occasion je change complétement mon PC.

Il va donc me falloir retrouver/lister toutes les applications que j’utilise et les ré-installer toutes.

Pour le premier point, lister les applications utilisé, je peux me baser sur un fichier que je maintiens depuis que je suis sur Ubuntu (avec plus ou moins d’assiduité).

Pour le deuxième point (ré-installation), il y a peu de temps je suis tombé sur cet article A Cleanstart for your new Ubuntu (Install Packages from a list) qui met a disposition un script bash pour ré-installer complétement un PC à partir d’un fichier contenant une liste de package.

Donc en mettant en forme mon fichier listant les applications utilisées avec le script réalisé par SilverWav, je peux gagner pas mal de temps.

Mais je n’étais pas complétement satisfait du script, ce dernier nécessite que tous les dépôts nécessaires soit préalablement configurés, or pour moi c’est 1 seul et même opération que d’ajouter le dépôt et d’installer les packages correspondant.

J’ai donc modifié le script d’installation et le format du fichier de configuration.

Fichier de configuration

Voici un exemple de fichier de configuration :

# ********************** Accessoires ******************************
 
parcellite # gestion du presse-papier
 
ppa:shutter/ppa
shutter # logiciel de capture d'écran évolué
 
# ********************** Autres ******************************
 
deb http://www-personal.umich.edu/~tjwatt/suldr/ debian extra > samsungCLX3175_driver.list
http://www-personal.umich.edu/~tjwatt/suldr/suldr.gpg
samsungmfp-configurator-data samsungmfp-configurator-qt4 samsungmfp-driver samsungmfp-data samsungmfp-scanner # driver imprimante Samsung CLX 3175
 
# ********************** Bureautique ******************************
 
ppa:claydoh/ppa
kmymoney2 # gestion des finances personnels
 
gcstar # gestionnaire de collections (livres)
 
# ********************** Education ******************************
 
gcompris tuxpaint # gcompris + logiciel de dessin matriciel pour les enfants
 
childsplay childsplay-alphabet-sounds-fr # Childsplay + langue française
 
pysycache pysycache-buttons-beerabbit pysycache-buttons-crapaud pysycache-buttons-wolf pysycache-click-sea pysycache-dblclick-butterfly pysycache-move-animals pysycache-move-food pysycache-move-plants pysycache-move-sky pysycache-move-sports pysycache-puzzle-cartoons pysycache-puzzle-photos # Psycache + extensions
 
# ********************** Graphisme ******************************
 
gimp gimp-help-fr # retouche d'image matriciels
 
inkscape # logiciel de dessin vectoriel
 
# Logiciels Photo
ppa:dlynch3/ppa
rapid-photo-downloader # Copie et renommage de photos depuis un appareil photo numérique
 
deb http://jbrout.free.fr/download/debian binary/ > jbrout.list
jbrout # tagging des photos
 
ppa:damien-moore/ppa
phraymd # tagging des photos
 
hugin # assemblage de photos en panorama
 
-f-spot # suppression de f-spot (mono+lourd)
 
# ********************** Internet ******************************
 
ppa:deluge-team/ppa
deluge-common deluge-gtk # IHM GTK du client torrent deluge
 
-transmission-common transmission-gtk # suppression de transmission client torrent installé par défaut dans Gnome
 
# Nouveautés : DAILY > BETA > DEV > STABLE (n'existe pas sous Linux)
#ppa:chromium-daily/ppa
#ppa:chromium-daily/beta
ppa:chromium-daily/dev
chromium-browser # navigateur web
 
pidgin # messagerie instantannée
 
-empathy empathy-common nautilus-sendto-empathy # suppression d'empathy loiciel de messagerie instantannée installé par défaut dans Gnome et de son intégration dans Nautilus
 
thunderbird thunderbird-locale-fr thunderbird-gnome-support # client email
 
deb http://linux.dropbox.com/ubuntu lucid main > dropbox.list
key:FC918B335044912E
nautilus-dropbox # stockage on-line et synchronisation de fichiers
 
# ********************** Jeux ******************************
 
frozen-bubble # jeux où il faut exploser des boules en en associant 3 par couleur
 
# ********************** Outils sytèmes ******************************
 
htop # monitoring mémoire / cpu ...
 
language-pack-fr language-pack-gnome-fr # pack de langue pour completement franciser Ubuntu
 
# ********************** Son et Vidéo ******************************
 
deb http://packages.medibuntu.org/ lucid free non-free > medibuntu.list
key:0C5A2783
non-free-codecs # codecs audio-vidéo non libres
 
asunder # ripp des CDs
 
ppa:handbrake-ubuntu/ppa
handbrake-gtk # ripp des DVDs
 
ppa:c-korn/ppa
vlc # lecteur multimédia (audio/vidéo)
 
# ********************** Outils (non desktop) ******************************
 
autofs # montage automatique de système de fichier distant
 
nfs-common # client NFS
 
deb http://archive.canonical.com/ubuntu lucid partner > partner.list
sun-java6-jre # framework Java
 
vim # editeur VI amélioré

Le fichier de configuration accepte 7 formats de lignes différentes, correspondant chacune à différentes opérations d’installation.

Commentaires

Toutes les lignes commençant par un # sont considérées comme des commentaires

Ajout d’un dépôt PPA

Toutes les lignes du fichier de configuration commençant par « ppa: » sont considérées comme l’adresse d’un dépôt PPA et sera ajouté au système par la commande :

add-apt-repository ppa:[nom du ppa]

Les PPA (Personnal Package Archives) sont des dépôts mis à disposition de tout à chacun sur le site Launchpad, c’est à dire par Canonical.

Ajout d’un dépôt tierce (non PPA)

Toutes les ligne du fichier de configuration commençant par « deb http: » sont considérées comme l’adresse d’un dépôt APT.

Ce genre de ligne doit en plus respecter la syntaxe suivante :

deb http://url.serveur [branche] [sections] > [fichier].list

C’est à dire l’adresse du dépôt complet (ou ligne apt) suivi de « > » et d’un nom de fichier portant l’extension .list.

Le programme d’installation ajoute alors l’adresse du dépôt dans le fichier spécifié dans le répertoire /etc/apt/sources.list.d où les programmes apt (apt-get/aptitude) vont chercher la liste des dépôt lors d’un update.

Ajout d’une clé GPG

Deux façon de faire :

• Commencer la ligne par le mot-clé « key: » suivi de l’identifiant de la clé (cf.Ajouter la clé publique d’un dépôt (PPA))
• Donner l’url d’un fichier gpg, la ligne doit donc commencer par « http:« , finir par « .gpg » et être une URL valide

Suppression d’un package / logiciel

Toutes les lignes commençant par « - » seront considérées comme une liste de nom de package que l’on veut supprimer du système

Installation d’un package / logiciel

Toutes les autres ligne du fichier seront considérés comme une liste de nom de package à installer.

Script d’installation

Voici le script capable de prendre en charge le fichier de configuration et de réaliser les installation paramétrées.

Je ne suis pas un expert en programmation bash, il y a donc de fortes chance pour que l’on puisse améliorer le code, je suis preneur de toutes remarques et contributions.

#! /bin/bash
 
################################################################################
# Ubuntu (> 9.10) post installation script
# by VoidAndAny
#
# based on cleanstart-packages.list.sh by silverwav - OpenPGP key:03187548 15 Apr 2009
#
# this script read a config file and :
#     add PPA with add-apt-repository
#    add other repositories (not PPA) by writing them in a .list file in /etc/apt/source.list.d
#    add GPG keys
#     install package using aptitude install
#     remove pacakge using aptitude remove
#
################################################################################
#
# Usage:
# installation.sh
# (reads a file called packages.list by default).
# or
# installation.sh <filename>
#
# Any line starting with a # is ignored as are Blank lines.
# Line beginning by "ppa:" followed by a are used to add PPA repository
# Line beginning by "deb http", containing ">" followed by a file name with ".list" extension are used to add repository in /etc/apt/sources.list.d/
# Line beginning by "key:" followed by a key id are used to add GPG key from keyserver.ubuntu.com
# Line beginning by "http:", ending by ".gpg" are used to download and add GPG key froman URL
# Other lines are package list
#
################################################################################
clear
echo "--------------------------------------------------------------------------------"
echo "                 (cleanstart) Script for installing packages (client)                 "
echo "--------------------------------------------------------------------------------"
 
# ensure script is run as root/sudo
if [ "$(id -u)" != "0" ]
then
 echo ""
 echo "Must execute the script as root user."
 echo "--------------------------------------------------------------------------------"
 exit 1
fi
 
# check the argument count
if [ $# -gt "1" ]
then
 echo ""
 echo "Only one file with package names allowed."
 echo "--------------------------------------------------------------------------------"
 exit 1
fi
 
################################################################################
#### Main
#### args: (1)
#### 1. [out] List of input package names
################################################################################
 
CONFIG_FILE=""
# package names to be installed
PACKAGE_NAME_LIST=""
 
# check if filename was supplied as comand line parameter
if [ $# -eq "1" ]
then
 CONFIG_FILE=$1
else
 CONFIG_FILE=packages.list
fi
 
PACKAGE_NAME_LIST=$(cat $CONFIG_FILE | grep -v -E "(^#)|(^ppa:)|(^deb http)|(^-)|(^key:)|(^http:.*\.gpg)" | awk -F'#' '{ print $1}')
REMOVE_PACKAGE_LIST=$(cat $CONFIG_FILE | grep -E "^-" | awk -F'#' '{ print $1}' | sed 's/^-//g')
PPA_NAME_LIST=$(cat $CONFIG_FILE | grep -E "^ppa:" | awk -F'#' '{ print $1}')
REPOSITORY_KEY_LIST=$(cat $CONFIG_FILE | grep -E "^key:" | awk -F'#' '{ print $1}' | sed 's/^key://g')
GPG_URL_LIST=$(cat $CONFIG_FILE | grep -E "^http:.*\.gpg" | awk -F'#' '{ print $1}')
 
echo ""
echo "Installing PPA:" ${PPA_NAME_LIST}
echo "--------------------------------------------------------------------------------"
 
for i in $(echo  $PPA_NAME_LIST ); do
 add-apt-repository $i;
done
 
echo ""
echo "Installing other repositories (not PPA) "
echo "--------------------------------------------------------------------------------"
 
cat $CONFIG_FILE | grep -E "^deb http:.*>.*\.list" | awk -F'>' '{gsub(/[[:space:]]*/,"",$2) ; print $1 > "/etc/apt/sources.list.d/"$2 }'
 
echo ""
echo "Adding GPG key of other repositories (not PPA) "
echo "--------------------------------------------------------------------------------"
 
for i in $(echo $REPOSITORY_KEY_LIST ); do
 apt-key adv --keyserver keyserver.ubuntu.com --recv-key $i;
done
 
for i in $(echo $GPG_URL_LIST ); do
 wget -O - $i | sudo apt-key add - ;
done
 
echo ""
echo "Updating... "
echo "--------------------------------------------------------------------------------"
 
aptitude update
 
echo ""
echo "Installing packages:" ${PACKAGE_NAME_LIST}
echo "--------------------------------------------------------------------------------"
# ajouter le -y
aptitude install ${PACKAGE_NAME_LIST}
 
echo ""
echo "Uninstalling packages:" ${REMOVE_PACKAGE_LIST}
echo "--------------------------------------------------------------------------------"
 
aptitude remove ${REMOVE_PACKAGE_LIST}
 
echo ""
echo "Done"
echo "--------------------------------------------------------------------------------"

Utilisation

Pour utiliser ce script, il suffit de la lancer avec sudo en lui passant en paramètre le nom du fichier de configuration

Sources :

A Cleanstart for your new Ubuntu (Install Packages from a list)

Image par luvi sous CC BY-NC-ND

Admettons que l’on veuille exécuter une commande nécessitant une élévation de privilège via sudo (par exemple mount, shutdown, etc)  et que l’on veuille rediriger la sortie de cette commande dans un fichier appartenant à root nécessitant donc lui aussi une élévation de privilège (un quelquonque fichier de /etc).

Si on fait la combinaison suivante, cela échouera :

sudo ma_commande >> mon_fichier

En effet le sudo « fait effet » sur ma_commande mais pas sur la redirection, 2 solutions pour palier à ce problème :

1 – Lancer un terminal en super-utilisateur et éxécuter la commande sans le sudo :

sudo -s
ma_commande >> mon_fichier

2 – Utiliser la commande bash

sudo bash -c "ma_commande >> mon_fichier"

Pour info voici la commande qui m’a fait me poser cette question :

sudo bash -c "mdadm --detail --scan >> /etc/mdadm/mdadm.conf"

Edit :

18/01/2010 : Une autre solution : http://linux.leunen.com/?p=780

Jusqu’à peu ne connaissant pas la commande que je vais décrire ici, lorsque ce besoin se faisait sentir je faisais 2 echo « mon message » : 

echo "mon message"
echo "mon message" >> /ver/log/fichier.log

Ca marche mais c’est pas propre, surtout qu’il existe un outils répondant au besoin dans l’immense arsenal des programmes de base GNU.

Cette commande s’appelle tee.

Cette commande copie son entrée standard vers sa sortie standard et vers un fichier passé en paramètre.

Pour répondre au besoin posé, on peut donc faire :

echo "mon message" | tee -a /var/log/fichier.log

le paramètre -a indique au programme tee qu’il faut écrire dans le fichier ne mode ajout (append) et non pas écraser le contenu du fichier à chaque fois (ce qui peut être pratique)

Et voila c’est tout de même plus élégant que le double echo.

Source :

http://www.libordux.org/doc/cmdline/tips.php#tee

http://pwet.fr/man/linux/commandes/tee

Dans le but d’en faire toujours moins, j’ai cherché à automatiser le transfert des fichiers mp3 téléchargés vers le lecteur mp3.

En pré-requis il faut évidemment que le lecteur mp3 soit reconnu comme un disque USB (adieu iPod et autre systèmes à base de MTP). Dans mon cas pas de problème puisqu’il s’agit de transférer les fichiers mp3 ver une carte SD (mon « lecteur »)

Après quelques recherches je me suis orienté vers l’écriture d’une règle udev pour réaliser ce transfert automatique…

Tout d’abord Udev qu’est-ce donc ?

Je vous conseil la lecture de ce long article dont je vais m’inspirer pour rédiger ce post.

Donc en gros udev est le système servant à décrire et monter le périphériques sous linux.

Dans notre exemple udev va nous servir à  :

1. identifier de façon unique le périphérique USB branché (dans mon cas un lecteur de carte SD 3 en 1 de Kingston)
2. lancer un scripts qui va se charger de copier les fichiers mp3.

Identification du périphérique USB – écriture de la règle Udev

Il s’agit de la partie la plus « ardue » de la configuration et la partie pour laquelle chacun devra se débrouiller, il s’agit de trouver via udevinfo les informations qui permettront d’identifier de façon unique le périphérique USB dont le branchement déclenchera le transfert des fichiers.

Voici la trame des opérations à réaliser qui vous permettront d’y parvenir :

1 – Brancher le périphérique USB à identifier

2- Trouver le fichier /dev/sdxx correspondant à votre périphérique, pour cela analyser les messages affichés par dmesg lors du branchement du périphérique.

On aura alors quelque chose du genre :

SCSI device sda: 1003600 512-byte hdwr sectors (514 MB)
…
Attached scsi removable disk sda at scsi0, channel 0, id 0, lun 0
…
usb-storage: device scan complete

Le périphérique est donc accessible sur /dev/sda (ce qui est le cas dans la majorité des cas)

3- Analyser les données udevinfo. Cela se fait en exécutant :

udevinfo -a -p $(udevinfo -q path -n /dev/sda)

Cette commande sort tout un tas de données qu’il faut analyser pour trouver les informations pertinentes.

Vous trouverez ci-dessous le résultat de la commande udevinfo pour sda et sda1 pour mon lecteur de carte Kingston 3 en 1

udevinfo-sda-flashreader-kingston

udevinfo-sda1-flashreader-kingston

Dans mon cas j’ai identifié le périphérique par sa taille, ce qui est limite mais cela fonctionne.

Pour info pour le même lecteur de carte mais avec 2 cartes SD 2Go de marques différentes on a une taille différente dans le résultat du udevinfo (3870587 contre  3841911)

4 – Ecrire la règle udev, on créra le fichier 10-local.rules

sudo vim /etc/udev/rules.d/10-local.rules

Puis on ajoutera :

KERNEL=="sda1", SUBSYSTEM=="block", ATTR{size}=="3841911",  RUN+="/root/transfert.sh"

Toute la première partie de la régle est dépendente de votre périphérique et de l’attribut que vous avez choisi pour l’identifier.

La dernière partie (RUN) est commune, on indique à udev que lorsqu’il détecte le périphérique sda1 ayant une taille de 3841911, il doit exécuter le script transfert.sh dans root.

Script de transfert des fichiers mp3 vers les lecteur

Créer le fichier script transfert.sh

sudo vim /root/transfert.sh

Et y copier ceci :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#!/bin/sh
 
# paramétrage
# point de montage du périphérique USB
MOUNTPOINT="/mnt/transfertPodcast"
# fichier de log
LOGFILE="/root/transfertPodcast.log"
 
echo "---------- debut ----------" >> $LOGFILE
date >> $LOGFILE
 
# nom du device
echo "devname =" $DEVNAME >> $LOGFILE
 
# si le point de montage n'existe pas on le crée
if (!(test -d $MOUNTPOINT)) then
    echo "creation repertoire" $MOUNTPOINT >> $LOGFILE
    mkdir $MOUNTPOINT;
fi
 
# montage du périphérique USB
mount $DEVNAME $MOUNTPOINT
if [ $? != 0 ]; then
    echo "erreur de montage" $MOUNTPOINT >> $LOGFILE
    exit 1
fi
 
# sauvegarde des anciens podcast
mv $MOUNTPOINT/Podcast/*.mp3 $MOUNTPOINT/Podcast/_save/
 
# déplacement des nouveau podcast vers le périphérique USB
mv /home/mon_user/downloads/podcast/*.mp3 $MOUNTPOINT/Podcast/ >> $LOGFILE
 
# démontage du périphérique USB
umount $MOUNTPOINT
if [ $? != 0 ]; then
    echo "erreur de démontage" >> $LOGFILE
    /usr/bin/beep -f 1200 -n -f 1000 -n -f 1200
    exit 1
fi
 
# c'est fini : musique maestro
/usr/bin/beep -f 1000 -r 2 -n -r 5 -l 10 --new
 
echo "-------- end - ok --------" >> $LOGFILE
echo "" >> $LOGFILE
exit 0

Ce script monte le périphérique USB identifié par la variable d’environnement DEVNAME dans le répertoire paramétré au début du script (MOUNTPOINT).

Les fichiers mp3 présents dans le répertoire Podcast du périphérique USB sont sauvegardés (déplacés) dans un sous répertoire _save

En effet on part de l’hypothèse que l’on garde pas les podcast une fois écoutés et que l’on ne branche notre lecteur mp3 en vue de le « recharger » en podcast que lorsque ceux présents dessus ont tous été écoutés.

On réalise donc une sauvegarde au cas où ce ne serait pas le cas mais c’est optionnel.

Le podcasts présents dans le sous-répertoire downloads/podcast du user réalisant le download sont ensuite transférés (déplacés) sur le périphérique monté.

Il faut bien sûr mettre en cohérence le chemin où l’on va chercher les podcasts avec celui paramétré dans votre script de téléchargement des podcasts.

Le prériphérique est alors démonté et une petite musique à base de beep (sudo aptitude install beep) est jouée

Le tout étant loggué dans fichier paramétré via LOGFILE

Ce script est très largement améliorable mais je ne pas pris le temps de le faire, on pourra citer comme axe d’amélioration :

• Purger le répertoire _save en se basant sur la date de copie des fichier pour ne garder que la date d-1 (est-ce faisable ?)
• Déplacement des logs
• Purge des logs
• …

Avertissement :

Le but de ce post est de montrer comment il est possible d’automatiser le téléchargement de torrents. Ce n’est en aucun cas l’apologie du piratage.

Cet avertissement effectué passons à la description du problème.

Comment faire pour automatiser le téléchargement de séries via un flux RSS ?

Au moment où j’ai mis ce système en place la version de Deluge utilisé ne permettait pas de s’abonner à un flux RSS. J’ai donc dû trouver une alternative qui à l’usage se révèle non seulement efficace mais aussi supérieure.

Cette alternative s’appelle Flexget.

La phrase d’introduction du site de Flexget décrit bien son usage et son rôle :

« FlexGet is a program aimed to automate downloading or processing content (torrents, podcasts, etc.) from different sources like RSS-feeds, html-pages, various sites and more. « 

Soit grosso-modo en Français :

« Flexget est un programme ayant pour rôle d’automatiser le téléchargement ou le traitement de contenus (torrents, podcasts) à partir de différentes source comme les flux RSS, les pages HTML, de nombreux sites et plus encore »

Bref ce qu’il nous faut pour répondre à la problématique posée.

Flexget va à partir d’un flux RSS nous informant en quasi temps réél de la mise à disposition d’un torrent, télécharger ce même torrent.

Là où il surpasse les clients torrent ayant la capacité à s’abonner à ces même flux RSS, c’est qu’on pourra lui indiquer ses préférence (en terme de qualité de release) et qu’il ne téléchargera qu’un seul torrent pour un même épisode d’une même saison d’une série donnée.

En pré-requis il nous faut un flux RSS nous informant de la mise à disposition d’un torrent. Dnas le but de ne pas trop inciter au priatage je n’indiquerais volontairement pas ici où trouver ce genre de site…

Installation de flexget

Flexget à besoin du package permettant à Python de parser le YAML et de feedparser permettant de parser les flux RSS, on installera donc  :

sudo aptitude install python-yaml python-feedparser

Téléchargement de la dernière version de flexget (la 0.9.3.2 dans mon cas) :

wget http://download.flexget.com/0.9/FlexGet_0.9.3.2.zip

Dézippage de l’archive téléchargée :

unzip FlexGet_0.9.3.2.zip

Et voila flexget est installé, reste à le paramétrer.

Paramétrage de flexget

Le paramétrage se fait dans un fichier yml, ce dernier peut avoir le nom que l’on veut et être placé où l’on veut, dans mon cas ce fichier de configuration se nomme configFlexget.yml et est placé dans le répertoire de flexget (lui même dans le home de mon user).

Ouvrir le fichier et copier une configuration ressemblant à ceci :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

global:
  download: ~/downloads/torrentfiles
 
settings:
  series:
    timeframe:
      enough: hdtv
 
feeds:
  Serie1:
    rss: http://xxxxx.net/serie1.xml
    series:
      - Serie1
 
   Serie2:
    rss: http://xxxxx.net/serie2.xml
    series:
      - Serie2

Point important :

Le YML (ou YAML) est un language structuré (comme le XML) mais il est beaucoup moins verbeux (pas de balise ouvrante et fermante)

En contrepartie la hierarchie des éléments est réalisé via l’indentation à base d’espace (surtout pas de tabulation).

Il convient donc d’être très rigoureux sur l’edition des fichiers yml.

La section global permet comme son nom l’indique le paramètrage global de flexget quelque soit le plugin utilisé par la suite, elle sert uniquement à définir le répertoire où les téléchargements vont êtres stockés.

La ruse consiste ici à mettre le même chemin que celui paramétré dans Deluge paramètre « Auto Add folder » (cf. mon article Installation d’un client torrent – Deluge), ainsi flexget télécharge les torrents et Deluge commence automatiquement le téléchargement.

Section settings, on met ici le paramétrage spécifique au plugins utilisés, dans le ca présent pour le plugin series il existe 2 paramètrages :

• timeframe \ hour : pas utilisé encore mais ça ne devrait pas tarder. Cela permet d’indiquer à flexget qu’il faut attendre un certain temps entre la mise à disposition d’un torrent et son téléchargement. L’utilité : attendre qu’une nouvelle release soit disponible.
• timeframe \enough : ce paramètre est l’une des force de Flexget, il indique quelle qualité de release est suffisante. Les valeurs possibles sont 1080p, 1080, 720p, 720, hr, dvd, hdtv, dsr, dsrip. Ainsi quand on a pas de télé HD il est inutile de télécharger du 1080p.

Vient ensuite la section de paramétrages de chacune des séries où l’on indique le nom de la série (Serie1) et le flux RSS associé.

Le paramètre feeds \ Serie1 \ series, qui a dans mon cas Series1 comme valeur, permet d’indiquer quelle est la série à télécharger dans le cas d’un flux recensant plusieurs séries.

Et voila concernant mon paramétrage, il ne faut pas hésiter à aller sur le site de Flexget pour voir les nombreuses possibilités de ce logiciel (téléchargement de comics, génération de flux RSS) et plus particulièrement les autres paramétrage du plugin serie

Pour tester votr fichier de configuration :

./flexget.py -c /home/svc/bin/flexget/configFlexGet.yml --check

Exécution de flexget

Pour exécuter flexget il suffit de faire :

./flexget.py -c ~/flexget/configFlexGet.yml

On peut alors evidemment ajouter cette ligne de commande dans une tache Cron….

Premier article sur ma linux-box.

Pour situer rapidement les usages de cette machine (j’en reparlerais plus longuement plus tard), il s’agit d’un vieux PC (Duron 1GHz) avec Ubuntu minimal et qui me sert de HTPC, de serveur de backup et de download.

Le sujet de cet article se situe dans le cadre de ce dernier point.

Faisant pas mal de route, j’ai le temps d’écouter la radio mais je me suis vite rendu compte qu’avec 1h matin et soir les infos avait tendance à passer en boucle.

D’où l’idée d’écouter des émissions qui m’intéressent vraiment, et c’est là qu’intervient le podcast.

Je me suis donc mis en quête d’un logiciel de podcast tournant sous linux.

Le besoin est le suivant :

• Paramétrage facile et souple
• Pas d’interface graphique

Installation et paramétrage de podracer

Après quelque recherche j’ai trouvé podracer qui est disponible dans le dépôt Universe d’Ubuntu (Gutsy dans mon cas) :

http://packages.ubuntu.com/gutsy/podracer

L’installation se fait donc par un simple :

sudo aptitude install podracer

Il faut ensuite paramétrer les podcasts que l’on souhaite télécharger.

Là aussi c’est très simple il suffit d’éditer / de créer le fichier le fichier subscription :

vim ~/.podracer/subscriptions

Ce dernier à une structure très simple :

adresse_du_podcast sous_répertoire

exemple :

# France Inter - CO2 Mon Amour
http://radiofrance-podcast.net/podcast09/rss_10006.xml CO2MonAmour

Les lignes commençant par # étant des commentaires.

(on verra l’usage du sous répertoire par la suite)

Il n’y a plus qu’à éditer le fichier podracer.conf pour indiquer au programme le répertoire de sauvegarde :

cp /etc/podracer.conf ~/.podracer/
vim ~/.podracer/podracer.conf

Dans mon cas :

# poddir is the directory where you want podcasts to be saved
# Directory names may be created dynamically based on time, date and many other
# possibilities.  Directory names based on feeds are listed in the subscriptions
# file.
poddir=$HOME/downloads/podcast/temp

Et puis on lance podracer :

podracer

Au premier lancement cela peut être long, très long, on pourra donc exécuter

podracer --catchup

Podracer loguera tous les podcasts comme téléchargés mais n’en téléchargera aucun en réalité.

Dans notre exemple on devrait donc voir sous le répertoire $HOME/downloads/podcast/temp/CO2MonAmour un/des fichier(s) mp3 de l’émission de France Inter.

Traitement des podcasts téléchargés

Avec podracer, on télécharge rapidement et facilement des podcasts, mais vous vous en rendrez compte à chaque site / podcasts un nom de fichier ayant un format différent.

Certains avec la date (avec des formats différents entre les podcast) d’autre sans, certain avec le nom de l’émission, d’autre sans.

De plus le lecteur mp3 que j’utilise (lien), lorsqu’on l’arrête retient la piste à laquelle il est rendu mais pas l’endroit dans la piste.

Or les podcasts d’une émission se présentent le plus souvent (tout le temps) sous la forme d’un fichier mp3 unique et recommencer à écouter une émission complète parce que la dernière fois on s’est arrêté 10 minutes avant la fin, non merci.

Donc l’idée était de faire un script bash de renommage des podcasts et de découper ces dernier en tronçon de x minutes.

Après de nombreux tâtonnements (c’était mon premier script) et divers recherches et inspiration sur le web voici le scripts fonctionnel :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#!/bin/bash
 
# répertoire de travail
PODPATH=~/downloads/podcast
TEMPDIR=$PODPATH/temp
DUREE=2.00
 
echo Téléchargement des podcasts
[ -f  ~/.podracer/tempsub ] && rm ~/.podracer/tempsub
# lance podracer qui va télécharger les podcats
podracer
 
echo Ménage des anciens podcasts
#vide les mp3 traité lors de la session précédente
[ "$(find $TEMPDIR -maxdepth 1 -iname '*.mp3')" ] && rm $TEMPDIR/*.mp3
 
echo Renommage des podcasts téléchargés
#pour tous les mp3 téléchargés par podracer on les renomes
for i in `ls $TEMPDIR/*/*.mp3`; do
 # date de création du fichier
 creationTime=$(stat -c "%y" "$i"|awk -F - '{print substr($1,3,4)$2substr($3,1,2)}')
 # on déduit le nouveau nom de base du fichier en prenant le nom du répertoire le contenant (spécifié dans ~/.podracer/subscrition)
 podName=`dirname "$i"|awk -F/ '{print $NF}'`
 
 # renomme / deplace le fichier
 # si un fichier ayant le même nom existe déjà (cas où plusieurs podcast d'une même emission téléchargé le même jour)
 if [ -f $TEMPDIR/"$creationTime"_"$podName"".mp3" ]; then
 # on ajoute un compteur
 COUNT=1
 while [ -f $TEMPDIR/"$creationTime"_"$podName"_"$COUNT"".mp3" ]; do
 let COUNT=COUNT+1
 done
 mv "$i" $TEMPDIR/"$creationTime"_"$podName"_"$COUNT"".mp3"
 else
 mv "$i" $TEMPDIR/"$creationTime"_"$podName"".mp3"
 fi
done
 
echo Découpage des podcasts téléchargés
# pour chacun des fichiers renomés et déplacés, on split le mp3 en section de
for i in `ls $TEMPDIR/*.mp3`; do
 echo "$i"
 NICENAME=`basename $i .mp3`
 # Send both stderr and stdout to /dev/null so that this is a quiet cron job
 mp3splt -t $DUREE -aqd $PODPATH -o $NICENAME-@n $i > /dev/null 2>&1
done

Le script est normalement pas trop mal commenté, mais voici ce qu’il fait :

• Suppression du répertoire ~/.podracer/tempsub, ce dernier contient les fichiers temporaires que podracer crée en cours de téléchargement. Si la précédente exécution ne s’est pas terminé correctement les fichiers temporaires ne sont pas detruits et leurs présence le téléchargment ultérieur du podcast.

• Pour tous les fichier mp3 présents dans un sous répertoire de ~/downloads/podcast/temp (paramétré dans podracer.conf) on les copie dans ~/downloads/podcast/temp en les renommant ainsi :

AAMMJJ_sousRepertoire_incrément.mp3

AAMMJJ : date
sousRépertoire : sous répertoire paramétré dans le fichier subscrition de podracer, d’où l’intérêt de mettre un nom caractérisant le podcast
incrément : optionnel au cas ou 2 podcasts de la même émission serait téléchargé le même jour

• Pour tous les fichier mp3 présents dans ~/downloads/podcast/tem, découpage du fichier en morceau de 2 minutes avec l’utilitaire mp3splt

Il faudra préalablement à l’exécution de ce script avoir installé mp3splt (sudo aptitude install mp3splt) et avoir fait un chmod 755 sur le script.

Ce script pourra ensuite être planifié dans une tache cron.