cbenz::blog

Sous Bash, je connaissais la substitution de commande, avec $(cmd) ou `cmd`, par exemple :

$ grep 'body' $(find -name '*.html')

Par contre je découvre la substitution de processus (process substtitution en anglais) : <(cmd) ou >(cmd) C'est pareil, sauf que le résultat de la commande est considéré comme un fichier (un lien depuis /dev/fd vers un pipe en réalité) et non comme une string.

C'est utile avec des commandes travaillant sur des noms de fichiers et ne sachant pas prendre en compte l'entrée standard (stdin).

Par exemple, j'ai écrit un script Python qui extrait les adresses email d'un fichier fourni en paramètres et les affiche sur la sortie standard :

$ extract-emails.py file.txt
$ cat *.txt | extract-emails.py  => erreur, le script ne sait pas faire
$ extract-emails.py <(cat *.txt)

On peut utiliser la forme >(cmd) qui fournit l'entrée standard à la commande cmd.

Exemple de la vie réelle : on utilise git et on veut connaître les fichiers du dépôt n'ayant pas changé depuis les 100 derniers commits :

$ comm -13 <(git diff --name-only HEAD~100 | sort) <(git ls-files | sort)

La commande comm prend 2 fichiers en entrée. Le premier (git diff) fournit la liste des fichiers ayant changé, le second la liste totale des fichiers. La liste des fichiers n'ayant pas changé est la différence du deuxième et du premier, et c'est le rôle de «comm -13».

Pour lancer un gnome-terminal en iso-8859-1, par exemple :

$ env LANG=fr_FR.ISO-8859-1 gnome-terminal --disable-factory

Mon Nokia N95 8GB reboote systématiquement lorsque je le branche en USB. Peu importe que je monte le système de fichiers ou non, il suffit que je branche la prise USB et il reboote sans prévenir. Cela ne se passait pas ainsi lorsque je l'ai acheté, quelque chose a dû se casser, ou c'est le noyau qui fait ça. D'un autre côté, sous Windows, le même problème survient.

Mais passons, car j'ai trouvé une solution : ObexFS en Bluetooth. Nautilus permet d'ouvrir le contenu de mon téléphone grâce à gnome-bluetooth, mais il passe par GVFS. Étant donné que je souhaite utiliser rsync pour sauvegarder le contenu de mon téléphone, cela pose problème. ObexFS est un système de fichiers en espace utilisateur s'appuyant sur FUSE.

Pour s'en servir :

• il faut installer le paquet obexfs et bluetooth
• l'utilisateur doit appartenir au groupe fuse
• il faut identifier l'adresse BD_ADDR (équivalent de MAC pour ethernet) du téléphone (hcitool scan)
• il faut ajouter ceci dans le fstab :

obexfs#-bXX:XX:XX:XX:XX:XX /mnt/n95 fuse user,fsname=obexfs#-bXX:XX:XX:XX:XX:XX 0 0

(remplacer XX:XX:XX:XX:XX:XX par l'adresse BD_ADDR de votre périphérique)

• créer le répertoire /mnt/n95 (groupe fuse, avec g+w)

$ mount /mnt/n95
$ ls /mnt/n95
$ umount /mnt/n95

about:config

set key general.smoothScroll to false.

Or, in preferences.js:

user_pref("general.smoothScroll", false);

Contre la loi HADOPI malvenue, je place un rectangle noir sur mon site web.

« La vente de la copie n’est pas un modèle économique viable. » (Paul Krugman, prix Nobel d’Economie 2008) source : article Marianne

Dans un article du 14 mars 2008, la revue Marianne publie un article contenant un document officiel qui explique que l'implémentation du dispositif technique (le mouchard) permettant la mise en œuvre d'HADOPI sera affectée par des limitations inhérentes à Internet, limitations qui ne pourront être «ni rapidement ni pleinement surmontées».

Moralité : le gouvernement a d'excellents conseillers techniques, mais les «conseillers lobbyistes» postillonnent plus fort.

Le répertoire /proc cache bien des secrets toujours intéressants à découvrir.

Question du jour : lorsqu'un processus ouvre un fichier en lecture, j'aimerais savoir à quelle position se trouve le curseur de lecture à l'intérieur du fichier. Et cela, bien entendu, sans programmer cela dans le programme qui lit le fichier : je veux trouver l'information par l'extérieur (le shell, ou un autre programme).

En l'occurence, je fais tourner un script Python qui parse linéairement un énorme fichier XML d'OpenStreetMap de 1.3gb, et je voudrais afficher le pourcentage d'avancement du parsing.

Le plus simple est de se situer au niveau des file descriptors ouverts par le processus. Tour d'horizon :

$ pidof python
8056
$ ls -l /proc/8056/fd
cbenz@marguerite:/proc/8056/fdinfo$ ls -l /proc/8056/fd
total 0
lrwx------ 1 cbenz ee 64 mar 26 11:28 0 -> /dev/pts/7
l-wx------ 1 cbenz ee 64 mar 26 11:28 1 -> /home/cbenz/projet/log
lrwx------ 1 cbenz ee 64 mar 26 11:28 2 -> /dev/pts/7
lr-x------ 1 cbenz ee 64 mar 26 11:28 3 -> /home/cbenz/projet/hexagone-latest.osm
lr-x------ 1 cbenz ee 64 mar 26 11:28 4 -> /home/cbenz/projet/hexagone-latest.osm

On voit que le processus 8056 ouvre 5 fichiers, et présentement le processus a ouvert hexagone-latest.osm 2 fois, ce qui est logique puisque mon script Python l'ouvre plusieurs fois (mais ce n'est pas le sujet).

Ensuite, il existe le répertoire fdinfo qui permet d'obtenir des informations sur les file descriptors ouverts. Par exemple le 4 :

cbenz@marguerite:~$ cat /proc/8056/fdinfo/4
pos:	211816448
flags:	0100000

Ce qui nous intéresse ici est l'information «pos», qui donne la position en octets depuis le début du fichier. Pour connaître la taille en octets du fichier :

cbenz@marguerite:~$ ls -lL --block-size=1 /proc/8056/fd/4
-rw-r--r-- 1 cbenz ee 1383266367 fév 26 03:31 /proc/8056/fd/4

Heureusement, mon grand-père m'a appris la règle de trois, un jour. En faisant une division, on devrait trouver le pourcentage.

Voici un script qui utilise ces connaissances pour afficher le pourcentage à la fin. Je l'ai appelé fd_percent.sh :

#!/bin/sh

function usage {
    echo 'usage: fd_percent.sh pid fd'
    exit -1
}

[ $# -gt 2 ] && usage
[ -z $1 ] && usage
[ -z $2 ] && usage

pid="$1"
fd="$2"

file_size=`ls --block-size=1 -lL /proc/$pid/fd/$fd | cut -d ' ' -f 5`
current_pos=`cat /proc/$pid/fdinfo/$fd | grep 'pos:' | cut -f 2`

percent=`echo $current_pos/$file_size*100 | bc -l`
percent_formatted=`env printf '%.2f
' $percent`

echo $percent_formatted

Exemple d'utilisation :

cbenz@marguerite:~$ fd_percent.sh 8056 4
15,87

Nickel, mission accomplie.

aptitude install molly-guard

molly-guard protects machines from accidental shutdowns/reboots.

Si vous tapez halt ou reboot dans une session ssh, molly-guard vous demandera de confirmer : incroyablement utile !

Après avoir longtemps cherché un logiciel permettant de relever un moreau de musique sur papier (mélodie ou grille d'accords).

Bien entendu, si j'ai qualifié ce post de projet, c'est que je n'ai rien trouvé en logiciel libre.

Voilà la liste des logiciels propriétaires que j'ai trouvés :

• Twelve Keys
• Transcribe! (existe en version Gtk sous GNU/Linux, mais propriétaire !)
• Express Scribe (à la base utilisé pour relever les discours)
• Solo Explorer

Ah, le monde merveilleux du Shareware ! Cet article du Linux Journal présente les logiciels propriétaires sous GNU/Linux dédiés à la musique.

Note de vocabulaire : un relevé musical se traduit en anglais par transcription, mais en français une transcription est l'adaptation d'une composition à un médium — instrument ou voix humaine — pour lequel elle n'a pas été écrite initialement.

Plusieurs approches existent :

• les logiciels qui disent faire tout automatiquement. Je n'y crois pas trop et ça ne m'intéresse pas.
• les logiciels qui aident à faire le relevé avec des fonctions de navigation évoluées, ou de travail sur le son. Je préfère largement cette approche et c'est celle-ci que je choisis de mettre en œuvre.

Il peut être pratique d'utiliser une ou deux pédales commandées avec les pieds pour jouer et stopper le morceau de musique.

• Cette page détaille les différentes pédales utilisables avec Express Scribe (logiciel propriétaire)
• Cette page détaille les différentes pédales utilisables avec Transcribe! (logiciel propriétaire)
• Cette page détaille l'utilisation des broches utilisées dans les câbles des pédales.

Voici une liste non exhaustive des fonctionnalités que je prévois d'implémenter :

• affichage de la waveform (et peut-être du spectre)
• repérage des parties du morceau grâce à des marqueurs
• saisie de la grille d'accords
• snap grid des mesures et des temps, avec peut-être détection du tempo
• loops (nommés) avec pause réglable entre les répétitions
• key bindings très accessibles, surtout pour les marqueurs et les loops (pourquoi pas des bindings pour le window manager, pour éviter d'avoir à donner le focus à l'appli)
• changement du tempo en préservant le pitch
• changement du pitch en préservant le tempo
• détection des notes grâce à FFT
• support des pédales

Les fonctionnalités du type equaliseur ne seront pas implémentées dans la mesure où un autre logiciel peut les prendre en charge (avec Jack).

Ceci est un premier jet, n'hésitez pas à commenter pour proposer des améliorations.

Je compte utiliser les technos suivantes :

• Gtk
• Gstreamer
• Python
• pourquoi pas Vala

Wiki de développement : cette page.

Comment mutualiser un clavier et une souris entre plusieurs machines utilisant Xorg, à travers SSH.

Le copier-coller est pris en charge.

Au lieu de recopier cet article, je redirige :

http://www.cooldev.net/article-51-partager-le-clavier-et-la-souris-avec-x2x.html