1. Introduction
2. Vérification de l’état
3. Désactivation
4. Sources

Introduction

Dans certains cas la désactivation de l’IPv6 permet d’accélérer les connexions Internet. Ceci est lié au fait que bon nombre d’applications essayent d’abord de trouver l’adresse IP en passant par l’IPv6 puis, en cas d’échec, retentent l’opération en utilisant l’IPv4. (cf. Désactiver IPv6 permet d’accélérer les connexions Internet (fr) pour une explication détaillée)

Vérification de l’état

Avant d’effectuer quelque modification que ce soit, il peut être intéressant de vérifier l’état de l’IPv6.

La commande qui suit retourne 0 si le protocol est activé et 1 s’il ne l’est pas:

$ cat /proc/sys/net/ipv6/conf/all/disable_ipv6

Désactivation du protocol

Dans le cas où la commande précédente retourne 0, il suffit d’exécuter la commande qui suit afin d’ajouter quelques lignes au fichier de configuration /etc/sysctl.conf. Après redémarrage le support de l’IPv6 sera désactivé.

$ echo "
#disable ipv6
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1" | sudo tee -a /etc/sysctl.conf

Sources

• How To Disable IPv6 In Ubuntu 10.04 Lucid Lynx (en)
• Désactiver IPv6 permet d’accélérer les connexions internet (fr)

1. Principes
2. Redirections
   1. Sortie standard: sdtout
   2. Sortie d’erreur standard: sdterr
   3. Entrée standard: sdtin
   4. Le Pipe
3. Canaux
   1. Création de canaux
   2. Redirection de canaux
4. Device /dev/null
5. Script shell
6. Exemples
7. Sources

Principes

L’exécution d’une commande shell va créer un processus qui ouvrira trois flux correspondants à trois canaux (ou file descriptors):

• Le canal 0 est l’entrée standard stdin dans lequel le processus va lire les données.
  Par défaut stdin correspond au clavier.
• Le canal 1 est la sortie standard stdout dans lequel le processus va écrire les données.
  Par défaut stdout correspond à l’écran.
• Le canal 2 est la sortie d’erreur standard stderr dans lequel le processus va écrire les messages d’erreur.
  Par défaut stderr correspond à l’écran.

Il est possible de modifier le fonctionnement par défaut et de rediriger les différents flux d’entrées/sorties afin que le processus interagisse avec un autre flux.

En outre, en plus des trois canaux par défaut, sept autres canaux, numérotés de 3 à 9, peuvent être ouvert en entrée ou en sortie selon les besoins. Ce qui ramène le nombre total de canaux utilisables simultanément et en parallèle à dix.

Redirections

Sortie standard: sdtout

L’opérateur de redirection > redirige la sortie standard stdout (canal 1), qui est l’écran par défaut, vers un fichier. Si ce dernier n’existe pas un nouveau fichier est alors créé, sinon il est écrasé.

Ceci peut être gênant dans le cas où le contenu du fichier doit être conservé. Dans cette situation, l’utilisation de l’opérateur de redirection >> est privilégié. Avec cet opérateur, si le fichier n’existe pas un nouveau est créé, sinon les données sont ajoutées à la fin du fichier.

Syntaxe:
command > /path/to/some/file
command >> /path/to/some/file

• > ou 1> redirige la sortie standard stdout dans le fichier list.txt

  $ ls > list.txt
  ou
  $ ls 1> list.txt

• >> ou 1>> redirige la sortie standard stdout en mode ajout dans le fichier list.txt

  $ ls >> list.txt
  ou
  $ ls 1>> list.txt

Sortie d’erreur standard: sdterr

La redirection de la sortie d’erreur standard stderr (canal 2) est régie par les mêmes règles que la redirection de la sortie standard stdout à la différence que le numéro de canal doit être mentionné avant l’opérateur de redirection > ou >>.

Syntaxe:
command 2> /path/to/some/file
command 2>> /path/to/some/file

• 2> redirige la sortie d’erreur stderr dans le fichier error.log

  $ bad_command 2> error.log

• 2>> redirige la sortie d’erreur stderr en mode ajout dans le fichier error.log

  $ bad_command 2>> error.log

Entrée standard: sdtin

La redirection de l’entrée standard stdin (canal 0), par défaut le clavier, est moins courante que la redirection des sorties. Néanmoins, utilisée à bon escient, elle peut être d’une grande utilité. Pour interagir avec les flux d’entrée, deux oprateurs sont disponibles.

L’opérateur < permet d’utiliser des données provenant d’un fichier au lieu du clavier.

L’opérateur << token, également appelé heredoc, lit l’entrée standard jusqu’à la première occurence de mot clef "token". Par défaut, les variables et commandes entre backticks (`) sont évaluées et les caractères spéciaux devront être verrouillés par des backslash (\). Ceci peut-être évité en mettant le mot clef de l’opérateur entre apostrophes (') ou entre guillemets (").

Syntaxe:
command < /path/to/some/file
command << token Contenu a rediriger token
command << "token" Contenu a rediriger token

• < redirige le fichier inputFile.txt dans l’entrée standard stdin

  $ cat < inputFile.txt

• << EOF lit l’entrée standard jusqu’à la deuxième occurence du mot clef EOF et redirige le contenu dans l’entrée standard stdin

  $ cat << EOF
  > Line 1 sans verrou sur le $dollars
  > Line 2 avec verrou sur le \$dollars
  > Line 3 repertoire courant $PWD
  > EOF
  Line 1 sans verrou sur le
  Line 2 avec verrou sur le $dollars
  Line 3 repertoire courant /home/user
  $

• << "EOF" lit l’entrée standard jusqu’à la deuxième occurence du mot clef EOF et redirige le contenu dans l’entrée standard stdin sans interpréter les variables

  $ cat << "EOF"
  > Line 1 sans verrou sur le $dollars
  > Line 2 avec verrou sur le \$dollars
  > Line 3 repertoire courant $PWD
  > EOF
  Line 1 sans verrou sur le $dollars
  Line 2 avec verrou sur le \$dollars
  Line 3 repertoire courant $PWD
  $

Le Pipe

La redirection entre processus avec le pipe (|) permet de créer des “pipelines”, c’est à dire qu’une ligne de commande est constituée d’une succession de commandes dont la sortie de chacune est redirigée dans l’entrée de la suivante.

Contrairement aux autres opérateurs de redirection, le pipe ne passe pas par un fichier mais utilise une mémoire tampon (buffer)

Syntaxe:
command_1 | command_2
command_1 | command_2 | command_3 | ... | command_N

• Redirige la sortie standard stdout de la commande ls dans l’entrée standard stdin de la commande less

  $ ls | less

• Liste les fichiers de répertoire courant, les trie par ordre décroissant (du plus gros au plus petit) puis affiche les 5 premier résultats

  $ ls -al | sort -r -n -k 5 | head -5

Canaux

Création de canaux

En plus des trois canaux standard, sept autres canaux, numérotés de 3 à 9, peuvent être créés en entrée ou en sortie. La commande exec permet d’affecter un canal jusqu’à sa fermeture (exec num_canal<&-).

Syntaxe:
exec num_canal> fichier
exec num_canal< fichier
exec num_canal<&-

• Affecte au canal 3 le fichier d’entrée input.txt. Les commandes pourront dès lors utiliser ce canal comme entrée standard stdin

  $ exec 3< input.txt

• Affecte au canal 4 le fichier de sortie file.txt. Dorénavant toute écriture dans le fichier file.txt pourra ce faire par le biais de ce canal

  $ exec 4> file.txt

• Redirige la sortie standard stdout vers le canal 4, soit finalement vers le fichier file.txt

  $ ls >&4
  ou
  $ ls 1>&4

• Libère le canal 4

  $ exec 4<&-

Redirection de canaux

On peut envisager, dans le cadre de certains traitements, de rediriger un canal dans un autre. Cela permet de regrouper des informations provenant de plusieurs flux distincts dans un seul et unique flux.

• &> redirige la sortie standard stdout ainsi que la sortie d’erreur standard stderr dans le fichier execution.log

  $ not_so_bad_command &> execution.log

• >&2 redirige la sortie standard stdout vers la sortie d’erreur standard stderr

  $ ls >&2

• n&>m redirige tout ce qui est écrit sur le canal n vers le canal m. De ce fait, 2&>1 redirige la sortie d’erreur standard stderr vers la sortie standard stdout

  $ bad_command 2>&1

• > crée le fichier list.txt à l’intérieur duquel sera inscrit le résultat de la redirection de la sortie d’erreur standard stderr vers la sortie standard stdout

  $ ls > list.txt 2>&1

  L’ordre d’utilisation des redirections est important. La commande suivante ajoute “Bonjour” au fichier hello.txt $ echo "Bonjour" 2> hello.txt 1>&2 alors que la commande suivante affiche “Bonjour” sur stdout. $ echo "Bonjour" 1>&2 2> hello.txt

• 5&<0 crée le canal 5 qui est une copie du canal 0 (stdin)

  $ exec 5&<0

Device /dev/null

/dev/null est un périphérique (device) spécial qui rejette toutes les données qui lui sont transmises. Toute redirection de données dans ce périphérique ne seront pas affichées à l’écran et seront définitivement perdues. Pour cette raison, il est souvent appelé “trou noir”.

Syntaxe:
command > /dev/null

• Redirige l’entrée standard stdout dans /dev/null

  $ cat file.txt > /dev/null

• Redirige l’erreur standard stderr dans /dev/null

  $ cat file.txt 2> /dev/null

• Redirige l’erreur standard stderr dans la sortie standard stdout puis redirige cette sortie combinée dans /dev/null

  $ cat file.txt > /dev/null 2>&1

Script shell

Dans un script shell, il est également possible de rediriger les sorties dans un fichier par le truchement de la commande exec.

L’exemple qui suit illustre l’utilisation d’un script pour rediriger tous les flux dans le fichier /home/user/logs/execution_[date].log

#!/bin/bash
# Redirecting stdin and stdout using 'exec'

dest=/home/user/logs
fname=`date +execution_%d%m%Y_%H%M.log`

exec 1>$dest/$fname 2>&1

# search all occurences of 'Sample' in '.txt' files
find -name '*.txt' | xargs grep 'Sample'

Exemples

• Récupération et analyse des logs générés lors d’un update cvs en ridirigeant le sdterr vers le sdtin

  $ cvs up 2>&1 | grep --color '^U\|^P\|^A\|^R\|^M\|^C\|^?'

• Effectue un update cvs et ridirige le flux sdterr dans /dev/null. Ici, l’exécution de la commande grep n’est utile que pour colorer le résultat. Ce dernier sera d’ailleurs identique à l’exemple précédent.

  $ cvs up 2> /dev/null | grep --color '^U\|^P\|^A\|^R\|^M\|^C\|^?'

• Suppression de fichiers dans une archive

  $ find -type f -printf "zip -d %p META-INF/BadKey.DSA META-INF/BadKey.SF\n" | bash

Sources

• Redirection des entrées/sorties (fr)
• Des Zéros et des Nulls (fr)
• Advanced Bash-Scripting Guide (en)
• Input/Output Redirection in Unix (en)
• The best tips & tricks for bash, explained (en)

Ceci est plutôt déplaisant lorsque vous transférer de gros fichiers. Néanmoins il existe une solution: la commande rsync.

Prenons l’exemple d’une copie d’un fichier de mon poste sur un ordinateur distant. Dans ce cas, j’utiliserai la syntaxe suivante:

Syntaxe:
scp [source] [user]@[host]:[destination]

Exemple:
$ scp monTexte.txt toto@hostName:/tmp/

En cas de coupure de téléchargement, je vais reprendre le transfert avec la commande ci-dessous.

Syntaxe:
rsync --partial --progress --rsh=ssh [source] [user]@[host]:[destination]

Exemple:
$ rsync --partial --progress --rsh=ssh monTexte.txt toto@hostName:/tmp/

Les options utilisées sont les suivantes::

Afin d’éviter une saisie régulière de l’intégralité de cette commande, vous pouvez ajouter l’alias ci-après dans le fichier .bashrc de votre profile ('~/.bashrc'). Exemple: alias scpresume="rsync --partial --progress --rsh=ssh" Ainsi la commande scpresume fonctionnera comme la commande scp.

Sources

• Tip: scp Resume (en)

1. Compression
2. Changement d’encodage
3. Remplacement d’une chaîne
   1. Changement de CVS
   2. Changement du carriage return

Compression

Il peut être intéressant parfois de ne prendre un compte que certains fichiers lors de la création d’une archive zip.

La commande suivante permet de créer un fichier .zip (nommé sources.zip) contenant tous les fichiers ayant l’extension .java de manière récursive à partir du répertoire courant.

$ zip -r sources.zip . -i *.java

Changement d’encodage

Certains OS utilisent par défaut l’encodage de fichier UTF-8 (cas de GNU/linux) alors que d’autres utilisent l’encodage ISO-8859-1 (également appelée Latin-1). Cet encodage différent des caractères pose parfois des problèmes lorsque l’on souhaite réutiliser des fichiers créés sous un autre système.

Pour continuer à manipuler ces fichiers, deux commandes peuvent être utiles: file et iconv.

Pour convertir l’encodage d’un fichier provenant d’un iSeries (encodage EBCDIC), il faut utiliser le jeu de caractères IBM-1047. Pour ce genre de fichiers, il est également possible de les convertir à la volée ainsi le contenu de ce dernier sera affiché dans la console. Si vous désirez les éditer par la suite, il faudra rediriger la sortie dans un fichier. $ cat <fichier_ebcdic> | dd conv=ascii # ebcdic vers ascii ou $ cat <fichier_ascii> | dd conv=ebcdic # ascii vers ebcdic

N’utilisez pas le même nom pour la source et la destination au risque de perdre votre fichier!

Remplacement d’une chaîne

Cette commande remplace toutes les occurences de la chaîne de caractères recherchée dans le fichier par une nouvelle chaîne.

Syntaxe:
perl -pi -e 's/[old_string]/[new_string]/g;' [file_name]

Exemple:
$ perl -pi -e 's/hello/goodbye/g;' monTexte.txt

Une autre solution consiste à utiliser l’éditeur non interactif sed. Cet éditeur permet d’appliquer un certain nombres de commandes sur un fichier puis d’en afficher le résultat sur la sortie standard. Le fichier d’origine n’est de ce fait pas modifié.

Syntaxe:
sed 's/[old_string]/[new_string]/g;' [file_name]

Exemple:
$ sed 's/hello/goodbye/g;' monTexte.txt

Il est néanmoins possible de modifier le contenu du fichier d’origine en ajoutant l’option -i.

La commande ci-après recherche toutes les lignes contenant le mot nombre puis remplace le mot hello par goodbye si ce dernier est présent sur la ligne.

Exemple:
$ sed -i '/nombre/ s/hello/goodbye/g;' monTexte.txt

Changement de CVS

La commande ci-dessous permet de changer le serveur cvs d’un projet.

Syntaxe:
find -name Root | xargs perl -pi -e 's/[old_string]/[new_string]/g'; \
find -name Root.bak | xargs rm

Changement du carriage return

GNU\Linux et Windows n’encode malheureusement pas les fins de ligne de la même manière.

La commande suivante liste tous les fichiers (-type f) du répertoire courant (-maxdepth 1) et remplace tous les caractères de fin de ligne; \r\n (Windows) par \n (GNU\Linux).

Syntaxe:
find . -maxdepth 1 -type f | xargs perl -pi -e 's/\r\n/\n/g'; ls *.bak | xargs rm

1. Préambule
2. Paramètres régionaux pour une application
3. Paramètres régionaux des manpages

Préambule

Habitué à travailler avec un système d’exploitation en anglais, il m’arrive parfois d’avoir besoin de démarrer une application ou de consulter des fichiers d’aide en français.

Ceci peut généralement ce faire de manière très simple pour autant que les outils requis soient installés.

En ce qui me concerne, je définis au niveau de l’application gnome-language-selector (menu Système > Administration > Prise en charge de langues) la liste des langues que je désire utiliser ainsi que les paramètres globaux de prise en charge.

Ensuite, dans un terminal, j’affiche la liste des paramètres régionaux installés:

$ locale -a

Si par malheur le modèle désiré n’est pas listé, je procède à sa génération:

$ locale-gen fr_CH.UTF8

Ces deux étapes terminées, il m’est possible d’exécuter une application dans une autre langue que celle utilisée par défaut lors du démarrage de GNOME.

Paramètres régionaux pour une application

Le démarrage d’une application dans une autre langue peut ce faire soit via un terminal soit via un launcher.

Depuis un terminal

Syntaxe:
LC_ALL=[language] [application]

Exemple:
$ LC_ALL=fr_CH.utf8 gedit

Depuis un launcher

Un launcher GNOME démarre l’application en fonction des paramètres régionaux. Pour cette raison, je pense qu’essayer de modifier ce comportement ne serait pas très judicieux.

C’est pourquoi, partant du principe que la solution présentée plus haut pour le démarrage depuis le terminal n’était pas trop mauvaise, j’ai créé un script bash très basic pour contourner le problème.

Fichier customLC.sh

#!/bin/bash
# -*- coding: utf-8 -*-

LC_ALL=fr_CH.utf8 $1

Syntaxe:
bash customLC.sh [application]
ou
bash customLC.sh "[application] [options]"

Pour utiliser ce script dans un launcher, il suffit de renseigner le champs Command avec la syntaxe utilisée pour lancer le script dans un terminal.

Exemple:
bash customLC.sh "firefox %u"

L’utilisation des guillemets et nécessaire si vous désirez passez des paramètres d’exécution à l’application.

Paramètres régionaux des manpages

Pour consulter les pages de manuel dans une autre langue, il faut au préalable installer les packages de traduction.

Exemple pour les packages français:
sudo apt-get install manpages-fr manpages-fr-extra manpages-fr-dev

Ensuite, la consultation des pages de man s’effectue avec la syntaxe shell suivante:

Syntaxe:
LC_ALL=[language] man [command]
ou
man -L [language] [command]

Exemples:
$ LC_ALL=fr_CH.UTF8 man ls
ou
$ man -L fr_CH.UTF8 ls

Les pages man ne sont pas toujours traduites et sont souvent plus complète dans la version anglaise

Syntaxe:
sudo bash install.sh [options]

Sans options d’exécution, uniquement les applications communes à toutes les architectures sont installées. Il est toutefois possible de compléter l’installation des modules communs par le truchement des options suivantes:

#!/bin/bash
# -*- coding: utf-8 -*-

##
# =============================================================================
# Script for full system installation
#
# Author : Pascal Rapaz
# Version: 1.0.0
# Date   : 15.05.2010 Creation
#
# License: GPL-2+
#   This package is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This package is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   If you need the GNU General Public License write to:
#     Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
#     MA 02110-1301, USA.
#
# (c) 2008-2009, Pascal Rapaz (RapazP - pascal.rapaz@rapazp.ch)
# =============================================================================
##

UBUNTU_NAME=lucid

RED="\033[1;31m%10s %s\033[0m\n"
GREEN="\033[1;32m%10s %s\033[0m\n"
BLUE="\033[1;34m%10s %s\033[0m\n"

# execute the installation script
function launchInstall
{
    _isSuperUser

    printf "$BLUE" "[START]" "Installation script"

    if [ "$update" = "y" ]; then
        _aptList
        _update
    fi

    if [ "$common" = "y" ]; then
        common
    fi

    if [ "$development" = "y" ]; then
        development
    fi

    if [ "$xps" = "y" ]; then
        xps
    fi

    if [ "$update" = "y" ]; then
        _clean
    fi

    printf "$BLUE" "[END]" "Installation script"
}

# install common applications for all systems
function common
{
    # internet
    printf "$GREEN" "[INSTALL]" "Internet applications"
    apt-get -y install thunderbird amule xchat flashplugin-nonfree chromium-browser

    printf "$GREEN" "[INSTALL]" "Office applications"
    apt-get -y install openoffice.org-java-common alexandria

    # photo
    printf "$GREEN" "[INSTALL]" "Image manipulation"
    apt-get -y install geeqie gthumb inkscape

    # audio
    printf "$GREEN" "[INSTALL]" "Audio manipulation"
    apt-get -y install audacious audacious-plugins audacious-plugins-extra lame audacity easytag normalize-audio banshee sound-juicer

    # video and graphics
    printf "$GREEN" "[INSTALL]" "Video manipulation and graphics tools"
    apt-get -y install vlc mplayer mencoder ffmpeg compiz compiz-fusion-bcop compizconfig-settings-manager compiz-fusion-plugins-extra compiz-fusion-plugins-main

    # video codecs
    printf "$GREEN" "[INSTALL]" "Video codecs"
    apt-get -y install gstreamer0.10-ffmpeg gstreamer0.10-plugins-ugly gstreamer0.10-plugins-bad

    # network
    printf "$GREEN" "[INSTALL]" "Network application"
    apt-get -y install samba smbfs ssh gnome-rdp vinagre vino

    # archive manager
    printf "$GREEN" "[INSTALL]" "Archive manager"
    apt-get -y install unace rar p7zip-full

    # compiz
    printf "$GREEN" "[INSTALL]" "Miscalenous"
    apt-get -y install tomboy grsync purrr cvs asciidoc fop gparted fslint alexandria python-wxgtk2.8 vim grub2-splashimages htop comixcursors google-gadgets-gtk

    printf "$BLUE" "[INFO]" "Following applications must be added manually:"
    printf "$BLUE" "" "ubuntu-tweak DBVisualizer Eclipse Jajuk Opera Nero VirtualBox Xaraxtreme Zattoo"
}

# install particular applications for XPS
function xps
{
    # G15 LCD
    printf "$GREEN" "[INSTALL]" "Logitech G15 LCD screen"
    apt-get -y install g15composer g15daemon g15daemon-audacious g15stats
}

# install applications for development
function development
{
    # dev
    printf "$GREEN" "[INSTALL]" "Development"
    apt-get -y install sun-java6-jdk sun-java6-plugin meld python-pyexiv2 glade libbluetooth-dev bluefish

    # debian packages
    printf "$GREEN" "[INSTALL]" "Tools for debian packages creation"
    apt-get -y install build-essential dpkg-dev debhelper devscripts fakeroot alien

    # network security
    printf "$GREEN" "[INSTALL]" "Network security"
    apt-get -y install aircrack-ng kismet zenmap

    # language
    printf "$GREEN" "[INSTALL]" "Language support"
    apt-get -y install manpages-fr-extra manpages-fr-dev
}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Packages management
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# create apt list for specific applications
function _aptList
{
    printf "$GREEN" "[INFO]" "create list file for specific repositories then get gpg signature"

    # Banshee
    FILE=/etc/apt/sources.list.d/banshee.list
    printf "$GREEN" "[ADD]" "Banshee repository"

    echo deb http://ppa.launchpad.net/banshee-team/banshee-unstable/ubuntu $UBUNTU_NAME main > $FILE
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6E80C6B7

    # Bluefish
    FILE=/etc/apt/sources.list.d/bluefish.list
    printf "$GREEN" "[ADD]" "Bluefish repository"

    echo deb http://debian.wgdd.de/ubuntu jaunty main restricted universe multiverse > $FILE
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 0F719C35E394D996

    # Alexandria
    FILE=/etc/apt/sources.list.d/alexandria.list
    printf "$GREEN" "[ADD]" "Alexandria repository"

    echo deb http://ppa.launchpad.net/alexandria-team/ppa/ubuntu $UBUNTU_NAME main
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 929E5EC4
}

# update repository
function _update
{
    printf "$GREEN" "[CLEAN]" "update packages list"
    apt-get update
}

# clean repository
function _clean
{
    printf "$GREEN" "[CLEAN]" "Remove packages there is no longer requiered"
    apt-get -y autoremove
}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Helper functions
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Check if user are in su mode
function _isSuperUser
{
    # Test if you're in super-user mode
    if [ ! `id -u` -eq 0 ]
    then
        printf "$RED" "[ERROR]" "You must have root privileges to run this command!"
        exit 1
    fi
}

# print help
function usage
{
    echo
    echo "Usage: sudo bash install.sh [OPTION] "
    echo "Complete the ubuntu standard installation with custom applications"
    echo "Without any options, install only common applications"
    echo
    echo " Parameters:"
    echo "      --nocommon     Don't install common applications"
    echo "      --noupdate     Don't update or clean apt package list"
    echo "      --dev          Install common and development applications"
    echo "  -x, --xps          Install common, development and XPS specific applications"
    echo
    echo "  -h,   --help       Display this help then quit"
}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Launch part
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# retrieve command parameters
common=y
update=y
while [ "$1" != "" ]; do
    case $1 in
        --nocommon )  common=n
                      ;;
        --noupdate )  update=n
                      ;;
        --dev )       development=y
                      ;;
        -x | --xps )  xps=y
                      development=y
                      ;;
        -h | --help ) usage
                      exit
                      ;;
    esac
    shift
done

launchInstall

1. Introduction
2. Actions sur le résultat
   1. xargs
   2. -exec
   3. Exemples
      1. Recherche d’une expression
      2. Recherche dans des fichiers jar
3. Sources

Introduction

La commande find permet de chercher des fichiers et éventuellement d’effectuer une action sur les résultats recherche. Bien que sa syntaxe est quelque peu complexe, il n’en demeure pas moins qu’elle est très puissante et souple.

Dans les lignes qui suivent je n’ai pas pour prétention d’expliquer le fonctionnement de la commande find mais plutôt de donner quelques astuces afin de vous simplifier la vie lors d’une recherche.

find cherche de manière récursive les fichiers qui correspondent aux critères définis: nom (name), propriétaire (owner), groupe (group), type (type), autorisations (permissions), taille (size), etc.

Syntaxe:
find [where] [criteria]

Par défaut, le contenu d’un répertoire lié symboliquement n’est pas traité. Pour y remédier, il faut ajouter l’option ‘-L’.

Actions sur le résultat

Il existe deux moyens d’exploiter le résultat d’une recherche soit via la commande xargs, soit via l’option -exec, toutes deux ayants certains avantages et inconvénients.

xargs

Syntaxe de base:
find [where] [criteria] | xargs [command]

xargs divise les arguments reçus en paramètre avec des espaces ou des retour-chariots. Si un nom de fichier (ou de chemin) contient des espaces par exemple “mon document.odt”, xargs va interpréter “mon” et “document.odt” comme étant deux fichiers distincts.

La solution pour éviter ce problème consiste à ajouter le paramètre ‘-0‘ à la commande xargs et ‘-print0‘ comme dernier argument de la commande find. Ainsi les espaces de fin de chaînes sont remplacés par null au lieu de blanc.

De plus, dans le cas où le résultat de la commande find est vide, xargs ne mettra pas fin au traitement et tentera d’exécuter la commande cible ce qui peut occasionner une erreur dans le traitement de cette dernière. Pour éviter ce cas de bord on ajoutera l’option ‘-r‘ à la commande xargs.

Syntaxe adaptée:
find [where] [criteria] -print0 | xargs -0 -r [command]

Avantages

• Le traitement des résultats est plus efficace qu’avec l’option -exec
• Le résultat de la commande xargs peut être réutilisée avec un pipe (|)

-exec

Syntaxe:
find [where] [criteria] -exec [command] {} \;

L’option -exec (à ne pas confondre avec la commande shell exec) exécute la commande sur chaque fichier trouvé répondant aux critères de recherche.

La paire d’accolade est automatiquement remplacée par le nom du fichier. Si le nom du fichier contient des caractères spéciaux, le shell tentera de les interpréter. Pour éviter cette interprétation, les accolades doivent être entourées d’apostrophes ('{}') ou de guillemets ("{}").

De plus, l’instruction à exécuter (ou commande) doit être terminée par les caractères \; (ou ';') précédé d’un espace.

Exemples

Recherche d’une expression

Il est parfois nécessaire de pouvoir rechercher une chaîne de caractères dans une série de fichiers.

Les commandes suivantes effectuent cette recherche depuis le répertoire courant de manière récursive et affiche le résultat dans la console. L’une utilise la commande xargs, l’autre l’option -exec mais au final le résutlat sera identique.

Syntaxe:
find . -name '[file_pattern]' -print0 | xargs -0 -r grep --color '[string]'
ou
find . -name '[file_pattern]' -exec grep --color '[string]' '{}' \; -print

$ find . -name '*.txt' -print0 | xargs -0 -r grep --color 'linux'
ou
$ find . -name '*.txt' -exec grep --color 'linux' '{}' \; -print

Recherche dans des fichiers jar

Ci-après la commande find affiche le contenu de tous les fichiers jar depuis le répertoire courant.

$ find -name '*.jar' -exec jar tvf '{}' \;

Bien entendu, le résultat obtenu peut être redirigé avec un PIPE (|) vers une autre commande. Ainsi l’utilisation de grep permet de filtrer la sortie.

Ici, seuls les fichiers .xml contenus dans les jar seront affichés:

$ find -name '*.jar' -exec jar tvf '{}' \; | grep --color '.xml'

L’option --color utilisée avec la commande grep n’est pas obligatoire. Toutefois elle mets en valeur les résultats de la recherche ce qui simplifie la lecture.

Sources

• The find / xargs pipe (en)
• Bash – Complex Commands (en)
• find (en)
• 10 Tips for Using GNU Find (en)

Après avoir sué vainement pour synchroniser des répertoires et fichiers contenant des espaces par le biai d’un script bash, c’est tout naturellement que je me suis tourné vers python pour essayer de résoudre mon problème.

Quelques minutes ont suffit pour que mon appel de commande rsync soit opérationnel et utilisable. Cerise sur le gâteau, il est également possible d’utiliser des variables source et destination pour définir des listes de répertoires à synchroniser.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

##
# =============================================================================
# Author : Pascal Rapaz
# Version: 1.0.0
# Date   : 15.04.2010 Creation
#          19.04.2010 Added loop for multiple folders sync
#          22.04.2010 Added zenity to display execution log
#
# License: GPL-2+
#   This package is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This package is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   If you need the GNU General Public License write to:
#     Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
#     MA 02110-1301, USA.
#
# (c) 2010, Pascal Rapaz (RapazP - pascal.rapaz@rapazp.ch)
# =============================================================================
##
"""
Use rsync to synchronize files and folder even if there contains spaces.

To sync between a Linux and a Windows system, usually I use these options:
   OPTS="-rvDz"

To sync two Linux systems, usually I use these options:
   OPTS="-av"
"""

from subprocess import Popen, PIPE

# source and destination folders
SRC = ["/mnt/win_share/projets en cours/Spécifications métier/",
       "/mnt/win_share/RP/MPP/projets en cours/Spécifications techniques/"
      ]
DEST = ["/home/user/project/Specifications_metier/",
        "/home/user/project/Specifications_techniques/"
       ]

# rsync options
OPTS = "-rvDz"
FILES = "--include '*.doc' --include '*.xls' --include '*.ppt' --include '*.pdf' " +\
        "--exclude '*.*' --exclude '@rchive'"

GLOBAL_STDOUT = ''
GLOBAL_STDERR = ''

# prepare and launch the command
for i in range(0, len(SRC)):
    cmd = "rsync " + OPTS + " " + FILES + " '" + SRC[i] + "' '" + DEST[i] + "' "
    stdout, stderr = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE).communicate()

    GLOBAL_STDOUT += "\n[cmd] " + cmd + "\n\n" + stdout
    GLOBAL_STDERR += stderr
#endFor

# use zenity to open a gtk dialog box that display sdtout and stderr
if (GLOBAL_STDOUT.strip() != '' or
    GLOBAL_STDERR.strip() != ''):

    log = "[STDOUT]\n" + GLOBAL_STDOUT

    if (GLOBAL_STDERR.strip() != ''):
        log += "\n[STDERR]\n" + GLOBAL_STDERR
    #endIf

    cmd = 'echo "%s" | zenity --height="480" --width="640" --text-info --title="Execution log"' %(log)

    Popen(cmd, shell=True).communicate()
#endIf