urxvt: modifier le fond pendant l’exécution

J’aime assez avoir de la vrai transparence sur un terminal, urxvt le permet, j’en profite. Par contre, quand des fenêtres s’entassent comme ça m’arrive trop souvent à mon goût, et que j’ouvre un fichier de configuration ou les sources d’un programmes, avec la colorisation, c’est tout simplement illisible…

Donc, là commence la recherche, il faut trouver comment modifier la configuration d’urxvt en cours de fonctionnement, je connaissais comment changer la police mais ça s’arrêtait là… Une recherche sur le net n’a pas donné grand chose, mais c’est sans compter sur les pages man 🙂

urxvt propose une page à la section 7:

man 7 urxvt

Cette dernière couplée avec celle par défaut répond à toute les questions sur la configuration, on y découvre (si ce n’est pas déjà connu), qu’il suffit d’utiliser les caractères d’échappement pour modifier certaines ressources.
La syntaxe est simple:

echo -e '\033]Ps;Pt\007'

Ps étant le code de la ressource à modifier et Pt la valeur, ainsi pour changer de fond d’écran:

# Fond noir opaque:
echo -e '\033]11;#000\007'
# Fond noir transparent à 80%:
echo -e '\033]11;[80]#000\007'

Reste plus qu’à mettre un raccourci, il suffit de rajouter deux ressources URxvt.keysym dans le ~/.Xdefaults:

URxvt.keysym.Control-t: command:\033]11;[80]#000\007
URxvt.keysym.Control-M-t: command:\033]11;#000\007

Ctrl-Alt-t enlève la transparence.
Ctrl-t la remet.

Il est bien ce urxvt quand même.

LDAP, Dovecot, fetchmail, procmail

Le but ici est de mettre en place un serveur imap avec une identification par serveur LDAP qui pourra éventuellement servir de carnet d’adresse partagé.
Le point de départ est un ensemble de compte mails hébergés sur un serveur qui ne propose malheureusement qu’un accès pop3.
Ça permet entre autre d’avoir un double des mails par rapport aux clients que peuvent avoir les utilisateurs ainsi que d’avoir une politique de sauvegarde (ça peut toujours servir), de partager un carnet d’adresses et même un ou des répertoires de mails.

Vu que je ne décris que la configuration minimum pour que ça fonctionne, il ne faut pas hésiter à pousser la recherche, notamment pour une définition plus poussée des droits d’accès à l’annuaire LDAP, je laisse celle par défaut ici.

Serveur d’authentification: LDAP
Serveur IMAP: Dovecot
Utilitaires de rapatriement des mails: fetchmail, procmail.

Commençons par installer et configurer openLDAP:

pacman -S openldap

Générons d’abord un mot de passe:

$ slappasswd 
New password: 
Re-enter new password: 
{SSHA}/lzUz+0mTGl9DGnG5XJQBdKxwaWNUSic

Configuration de /etc/slapd.conf:

include		/etc/openldap/schema/core.schema
include		/etc/openldap/schema/cosine.schema
include		/etc/openldap/schema/inetorgperson.schema
include		/etc/openldap/schema/misc.schema
include		/etc/openldap/schema/nis.schema
pidfile   	/var/run/slapd.pid
argsfile  	/var/run/slapd.args
database	bdb
suffix		"dc=home,dc=lan"
rootdn		"cn=admin,dc=home,dc=lan"
rootpw		{SSHA}/lzUz+0mTGl9DGnG5XJQBdKxwaWNUSic
directory	/var/lib/openldap/openldap-data
index	objectClass	eq

Peuplons un peu la base, test.ldif:

dn: dc=home,dc=lan
objectClass: domain
dc: home


dn: ou=people,dc=home,dc=lan
ou: people
objectClass: top
objectClass: organizationalUnit


dn: ou=group,dc=home,dc=lan
ou: group
objectClass: top
objectClass: organizationalUnit


dn: cn=dovecot, dc=home, dc=lan
objectClass: top
objectClass: person
objectClass: organizationalPerson
cn: dovecot
sn: dovecot


dn: uid=tuxce,ou=people,dc=home,dc=lan
uid: tuxce
cn: tuxce last name
givenName: tuxce
sn: tuxce
mail: tuxce@home.lan
objectClass: top
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
displayName: tuxce
ldapadd -D 'cn=admin,dc=home,dc=lan' -x -W -f test.ldif

Définissons un mot de passe pour dovecot:

ldappasswd -D 'cn=admin,dc=home,dc=lan' -x -W -S 'cn=dovecot,dc=home,dc=lan'

On devrait déjà avoir un serveur utilisable, à chacun de configurer les droits d’accès selon son schéma.

Installation et configuration de Dovecot:
Sous archlinux, comme d’habitude:

pacman -S dovecot

Le serveur imap accueillera des comptes n’ayant pas forcément d’équivalent en terme de compte utilisateur sur le serveur, il nous faut donc utiliser des utilisateurs virtuels.

Dovecot devra utiliser un seul utilisateur que l’on va nommer vmail et les boîtes au lettres seront stockées dans son répertoire personnel:

useradd -s /bin/nologin -m -d /home/vmail -c 'Virtual Mail User' vmail

Modification de /etc/dovecot.conf (je n’indique ici que ce que j’ai modifié):

mail_location=maildir:/home/vmail/%u
mail_uid = vmail
mail_gid = vmail
auth default {
  mechanisms = plain
  passdb ldap {
    args = /etc/dovecot/dovecot-ldap.conf
  }
  userdb ldap {
    args = /etc/dovecot/dovecot-ldap.conf
  }
}

Modification de /etc/dovecot/dovecot-ldap.conf:

hosts = localhost
dn = cn=dovecot,dc=home,dc=lan
dnpass = test
auth_bind = yes
auth_bind_userdn = uid=%u,ou=people,dc=home,dc=lan
ldap_version = 3
base = ou=people, dc=home, dc=lan
scope = subtree

user_filter = (&(objectClass=organizationalPerson)(uid=%u))

pass_attrs = uid=user,userPassword=password
pass_filter = (&(objectClass=organizationalPerson)(uid=%u))

Passons maintenant à la configuration de fetchmail et procmail:

pacman -S fetchmail procmail

Pour accéder au compte vmail vu que je l’ai crée avec le shell /sbin/nologin:

su - -s /bin/bash vmail

Création de .procmailrc:

PMDIR=/home/vmail
MAILDIR="$PMDIR/$1/"
LOGFILE=$PMDIR/procmail.log
VERBOSE=on

:0
"$MAILDIR"

Création de .fetchmailrc:

set daemon 1200 # 20 mn
set logfile fetchmail.log
set invisible
set bouncemail

poll "pop.exemple.org" protocol pop3 
user "tuxce@exemple.org" password "toto" mda "/usr/bin/procmail -a tuxce"
# Pour tester, je vous conseille d'utiliser la ligne suivante:
#user "tuxce@exemple.org" password "toto" keep mda "/usr/bin/procmail -a tuxce"
# Histoire de pas de se retrouver avec des mails perdus

Démarrage des serveurs et test:

/etc/rc.d/slapd start
/etc/rc.d/dovecot start
su - vmail -c "fetchmail"

Il ne reste plus qu’à configurer un client imap et à rafraîchir l’arborescence.

WordPress: résultat de recherche / 404

Après des migrations, des changements de styles, de configurations ou autre, il peut arriver que les articles d’un blog ne soient plus au même endroit qu’avant. Le but, bien sûr, est d’avoir le moins de changement possibles, mais certaines fois, c’est nécessaire et l’astuce suivante peut tout aussi servir pour ceux qui tapent une mauvaise adresse web.

Le principe est de rediriger toute erreur 404 (page non trouvée) vers une recherche dont les termes correspondent au contenu de l’adresse, tout en envoyant quand même l’erreur.

Sous wordpress, cela se fait simplement en modifiant la page 404.php de votre thème:

0);
include ("search.php");
?>

Exemple.

Récupérer des sites en flux RSS

Personnellement, j’utilise beaucoup les flux RSS pour suivre certains sites d’information, blogs ou forums, ça permet d’avoir un rapide coup d’œil sur ce qui pourrait m’intéresser, centralise le tout dans un seul logiciel et surtout ce logiciel s’occupe tout seul des mise à jours.

Malheureusement certains sites n’ont pas de flux, ou ne donnent que des versions courtes de leur articles, ce qui est leur choix, ça leur permet d’économiser la bande passante peut être ou oblige à passer sur leur site pour voir la pub qui va bien, alors bon je me suis pas vraiment posé la question (ou si mais j’y ai pas répondu) si j’avais le droit ou pas de passer outre la limitation, toujours est il que je le faisais au cas par cas, au bout de trois/quatre sites je me suis dit, essayons d’automatiser un peu tout ça.

Le principe est simple, le programme récupère une page avec la liste des articles et pour chacun d’entre eux, il récupère son adresse, télécharge sa page, récupère les informations telle que la date, l’auteur, le contenu à proprement dit et met le tout sous forme d’un fichier xml décrivant un flux RSS.

Cependant le principe a beau être simple, la sélection des informations se fait à l’aide d’expressions régulières et plus précisément à l’aide de sed, donc si vous y êtes réfractaires, ce qui va suivre peut choquer…

Alors, pour ceux qui sont restés, le script est configurable, chaque site correspond à un fichier qui définit comment récupérer les informations, pour l’exemple, je vais me baser sur le forum anglophone d’Archlinux qui ne propose pas de flux RSS.

EDIT: En fait, comme indiqué dans les commentaires, Archlinux utilisant un forum PunBB, ce dernier propose des flux, néanmoins, on n’a pas accès au contenu des posts, mais seulement aux titres des derniers sujets.

Nommons ce fichier arch.org:

# Fichier de configuration pour le flux du forum anglophone Archlinux.
RSS_URL="http://bbs.archlinux.org/"
BASE_URL="$RSS_URL/search.php?action=show_24h"
RSS_TITLE="Archlinux BBS"
RSS_DESCRIPTION="Archlinux BBS"
TZ_REMOTE="-0400"
SED_SELECT_URL=('/< \/tbody>/q' 's|.*\(viewtopic\?[^#]*#p[0-9]*\).*|'"$RSS_URL"'\1|p')

SED_ITEM_TITLE=('/» [^< ]\+<\/li>< \/ul>$/ { s/.*» \([^< ]\+\)<\/li>< \/ul>$/\1/p;q}')
SED_ITEM_AUTHOR=('/profile.php?/ { s|.*>\([^< ]*\).*|\1|p;q}')
SED_ITEM_DATE=('/

.*viewtopic.php/ {s/.*>\([^< ]\+\).*<\/a.*/\1/p;q}') SED_ITEM_CONTENT=('/class="postmsg"/,/<\/div>/ { /class="postmsg"/d;/^ *< \/div>/d; p}') pre_post () { POST_ID=${1#*#} SED_SELECT_ITEM=('/» [^< ]\+<\/li>< \/ul>$/ { p }' '/
/ { p }') } # La ligne suivante est là juste à cause du fait que wordpress rajoute des balises # (la flemme de chercher à contourner) #

Je vais pas ici détailler les expressions, sachez néanmoins qu’elles sont exécutées à l’aide de:

sed -n -e expr1 -e expr2

Pour ce qui est des variables:

  • RSS_URL: adresse du site.
  • BASE_URL: adresse de la page regroupant les articles (les derniers posts en ce qui concerne l’exemple)
  • RSS_TITLE: titre du flux
  • RSS_DESCRIPTION: description du flux
  • TZ_REMOTE: décalage horaire du site par rapport à UTC

Les variables commençant par $SED correspondent toutes à des listes d’expressions à passer à sed pour sélectionner un ou des éléments:

  • SED_SELECT_URL: les adresses des articles (posts)
  • SED_SELECT_ITEM: l’article avec toutes ses infos

Les expressions contenues dans les variables qui vont suivre s’appliquent à la partie de la page renvoyée par l’application de SED_SELECT_ITEM:

  • SED_ITEM_TITLE: titre de l’article
  • SED_ITEM_AUTHOR: auteur de l’article
  • SED_ITEM_DATE: date de l’article
  • SED_ITEM_CONTENT: contenu de l’article

La variable POST_ID contient quant à elle un identifiant permettant d’identifier (tiens donc…) de façon unique l’article, afin de ne pas re-télécharger sa page si on l’a déjà fait par le passé.
Il ne reste plus que la fonction pre_post() qui reçoit comme paramètre l’adresse de l’article et est exécutée avant le téléchargement de celui ci, pour le forum, on l’utilise pour définir l’id du post ainsi que l’expréssion pour le récupérer.

Récupérer le script grab.sh, et s’il est dans le même répertoire que arch.org:

./grab.sh arch.org

Si tout se passe bien, vous devriez avoir un répertoire:

/var/tmp/user_feed_cache-$USER/arch.org/

qui s’est créé avec dedans entre autre un fichier rss.xml que vous pouvez ouvrir avec votre agrégateur.

A partir de là, vous avez le choix de mettre des crontab pour mettre à jour le flux périodiquement ou si votre agrégateur le permet (liferea par exemple), renseignez lui la commande suivante:

/var/tmp/user_feed_cache-$USER/arch.org/grab.sh

( en modifiant $USER par le nom de votre utilisateur), et il s’occupera des mise à jours (ce script n’est créé que lors de la première exécution de grab.sh sans « -p »).

Par défaut, le script cherche les fichiers de configuration dans $HOME/.config/feed et dans le répertoire courant.

linuxplanet.com est un autre des sites pour lesquels j’utilise ce script dont voici le fichier de configuration: linuxplanet.
Voilà, il reste plus qu’à trouver les bonnes regexp 🙂

Les mises à jour magiques

Sous Archlinux, certaines mises à jour sont annonciatrices d’embouteillage sur le forum et le canal irc, mais aucune mise à jour n’est définitive et plusieurs manières existent pour revenir en arrière: Wiki downgrade, dont un projet initié par kumyo: ARM.

ARM permet de très facilement revenir dans le temps (pour peu que la journée voulue soit disponible), en théorie, il archive jusqu’à 6 mois (aujourd’hui il n’a que novembre 2009) de paquets Archlinux pour les dépôts testing, core, extra, community-testing et community, pour l’utiliser, il suffit de suivre le wiki, mais je vous propose ici un petit script qui permet d’automatiser le rollback, non pas que ça soit nécessaire mais vu le nombre d’utilisateurs sur le forum ayant des soucis avec une mise à jour, ça peut toujours servir, rollback:

#!/bin/sh

usage ()
{
	echo $(basename "$0")" date [pkg1 pkg2 ...]"
	exit 0
}

pacman_conf=$(mktemp)
pacman_mirror=$(mktemp)
verbose=0
[ -z "$1" ] && usage
rep=$(date -d "$1" +'%Y/%m/%d')
[ $? -ne 0 ] && exit 1
shift
url="http://arm.kh.nu/$rep/"
wget -q "$url" || exit 2
sed -e '/^#/d' -e "s|/etc/pacman.d/mirrorlist|$pacman_mirror|g" /etc/pacman.conf > $pacman_conf
echo Server=http://arm.kh.nu/$rep/'$repo'/os/$(arch) > $pacman_mirror
if [ -z "$1" ]; then
	pacman --config $pacman_conf -Syyuu 
else
	pacman --config $pacman_conf -Syy "$@"
fi
rm $pacman_conf
rm $pacman_mirror

Pour l’utiliser pour par exemple le 01/11/2009:

rollback 20091101 # remet le système à cette date là
rollback 20091101 xorg-server # remet le paquet xorg-server du 01/11/2009

La deuxième forme ne fonctionnera pas si les dépendances ne sont pas satisfaites.

Metacity: changer de bureau avec la molette

Le gestionnaire de fenêtre par défaut sous Gnome n’est pas parfait, mais parmi ses quelques défauts, il ne gère pas la molette de la souris pour le déplacement entre les bureaux, jusque là, je changeais tout simplement de gestionnaire en prenant Openbox qui s’intègre assez bien à gnome tout en restant très configurable, dernièrement, ayant eu un petit souci de détection du nombre de bureaux, j’ai voulu tester Metacity à nouveau… pas beaucoup de changements.

Enfin bref, tous ça pour présenter un petit programme permettant de prendre en charge la molette de la souris dont la version initiale a été postée sur un topic du forum d’Ubuntu par alduc1, ça fonctionne, mais génère une alerte de Metacity et se perd dans les bureaux si on en change depuis le pager ou avec les raccourcis clavier.

Je l’ai un peu modifié et lui ai rajouté des options, ce qui me permet de lui indiquer des fenêtres supplémentaires: sdesktop (git).
Pour utiliser le programme, on va d’abord l’installer, pour les utilisateurs d’Archlinux:

yaourt -S sdesktop

pour les autres:

wget http://tuxce.no-ip.org/cgit/public/sdesktop/snapshot/sdesktop-master.tar.gz
tar zxvf sdesktop-master.tar.gz 
cd sdesktop-master
make

Libre à vous de lancer make install ou tout simplement copier l’exécutable dans votre répertoire de scripts si vous en avez un.

Une fenêtre est identifiée entre autre par une classe ou un nom, pour avoir ces éléments:

$ # lancer la commande et cliquer sur une fenêtre, conky par exemple
$ xprop WM_CLASS WM_NAME
WM_CLASS(STRING) = "Conky", "Conky"
WM_NAME(STRING) = "Conky (host)"
$ # de même pour le fond d'écran sous Gnome/Nautilus
$ xprop WM_CLASS WM_NAME
WM_CLASS(STRING) = "desktop_window", "Nautilus"
WM_NAME(STRING) = "x-nautilus-desktop"

Il ne reste plus qu’à lancer:

sdesktop desktop_window Conky

(par défaut, « sdesktop » prend la fenêtre de fond de Nautilus)

Puis tester en utilisant la molette de la souris.
Le programme se lance en tâche de fond (-f pour l’inverse), il suffit de lui envoyer un SIGKILL ou SIGTERM pour le quitter:

killall sdesktop

Conteneurs Linux (LXC)

Il peut arriver qu’on ait besoin d’un autre environnement pour x raisons, si cet autre environnement est un OS différent, il faut se tourner vers les solutions de virtualisation tel que vmware, virtualbox ou encore kvm, par contre, si c’est pour tourner sous Linux, on peut s’en passer et utiliser un chroot.

Sous Archlinux, on peut se référer à la page chroot du wiki pour mettre en place assez rapidement un environnement fonctionnel.

L’inconvénient avec le chroot, c’est que le système y tournant n’est pas limité dans l’accès aux ressources, plusieurs systèmes permettent d’isoler un environnement, dont les « conteneurs linux » (LXC), que j’ai découvert avec cet excellent article: Architecture Domestique – Les Conteneurs Linux, on va voir comment mettre ça en place sous Archlinux, pour les explications détaillées, rien ne sert de se répéter, l’article cité précédemment explique ça très bien.
Pour plus d’informations, vous pouvez vous référer au site LXC (même si c’est moins détaillé).

Tout d’abord, LXC a besoin de certaines options dans le noyau, pour celui livré avec Archlinux, il nous faut en plus (certaines options nécessaires sont déjà activées):

CONFIG_GROUP_SCHED=y
CONFIG_SCHED_OTHER=y
CONFIG_FAIR_GROUP_SCHED=y
CONFIG_RT_GROUP_SCHED=n
CONFIG_USER_SCHED=n
CONFIG_CGROUP_SCHED=y
CONFIG_CGROUPS=y
CONFIG_CGROUP_DEBUG=n
CONFIG_CGROUP_NS=y
CONFIG_CGROUP_FREEZER=y
CONFIG_CGROUP_DEVICE=y
CONFIG_CPUSETS=y
CONFIG_PROC_PID_CPUSET=y
CONFIG_CGROUP_CPUACCT=y
CONFIG_RESOURCE_COUNTERS=y
CONFIG_CGROUP_MEM_RES_CTLR=y
CONFIG_CGROUP_MEM_RES_CTLR_SWAP=n
CONFIG_NAMESPACES=y
CONFIG_UTS_NS=y
CONFIG_IPC_NS=y
CONFIG_USER_NS=y
CONFIG_PID_NS=y
CONFIG_NET_NS=y
CONFIG_NET_CLS_CGROUP=n
CONFIG_DEVPTS_MULTIPLE_INSTANCES=y

Vous pouvez vous inspirer du PKGBUILD suivant: kernel26-lxc-2.6.31.4-1.src.tar

Il faudra de même refaire les paquets genre « nvidia » par exemple ou tout autre paquet lié directement au noyau.

Pour avoir tous les outils, il nous faut aussi installer les utilitaires LXC, un pkgbuild est disponible sous AUR: lxc-git (lxc-git sur ce site).

Si on veut avoir le support du réseau dans l’environnement, il nous faut configurer un pont, sous archlinux:

pacman -S bridge-utils

En supposant que vous êtes connectés en filaire (eth0) et en dhcp, il faut modifier /etc/conf.d/bridges comme suit:

bridge_br0="eth0"
BRIDGE_INTERFACES=(br0)

et /etc/rc.conf:

eth0="eth0 0.0.0.0 up"
br0="dhcp" 
INTERFACES=(eth0 br0)

Pour éviter un temps d’attente pour le passage des données, exécutez ceci une fois le système démarré:

brctl setfd br0 0

Une fois le noyau recompilé, la machine rebootée, les outils lxc installés, et le pont configuré, il faut créer l’environnement, pour l’exemple, on va créer un environnement 32 bits appelé « arch32 », il nous faut d’abord un fichier de configuration qu’on appellera arch32.conf:

#Nom de l'environnement
lxc.utsname = arch32
lxc.rootfs=/var/lib/lxc/arch32/rootfs
#Configuration du réseau
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
# Pour l'adresse, modifiez selon votre adressage.
lxc.network.ipv4 = 192.168.1.230/24
lxc.network.name = eth0
# Nombre de terminaux et pseudo terminaux disponibles
lxc.pts=1
lxc.tty=4

puis:

lxc-create -n arch32 -f arch32.conf

Cette commande crée un répertoire dans /var/lib/lxc:

arch32/
|-- config
|-- network
|   `-- veth0
|       |-- ipv4
|       |   `-- addresses
|       |-- link
|       |-- name
|       `-- up
|-- pts
|-- tty
`-- utsname

Il faut maintenant y mettre le système à proprement dit, en utilisant le pacman.conf du wiki:

[options]
HoldPkg     = pacman glibc
SyncFirst   = pacman
[core]
Server = http://mir.archlinux.fr/$repo/os/i686
[extra]
Server = http://mir.archlinux.fr/$repo/os/i686
[community]
Server = http://mir.archlinux.fr/$repo/os/i686

J’installe en plus du système de base, le serveur ssh:

mkarchroot -C /root/pacman.conf /var/lib/lxc/arch32/rootfs base openssh

Quelque modifications sont nécessaires car udev ne fonctionne pas dans le conteneur:

cd /var/lib/lxc/arch32/rootfs 
# Initialisation du répertoire /dev
cp -a lib/udev/devices/* dev/
# Création de certains fichiers supplémentaires
mknod -m 666 dev/tty c 5 0
mknod -m 666 dev/tty0 c 4 0
mknod -m 666 dev/random c 1 8
mknod -m 666 dev/urandom c 1 9
# Une console accessible depuis lxc-console, le fichier
# sera modifié par lxc.
mknod dev/tty1 c 136 4

Du fait qu’udev ne fonctionne pas, on a le choix entre modifier les scripts de démarrage d’Archlinux, ou alors mettre un fichier /sbin/init modifié comme ce qu’à fait Ulhume, ce qui a le mérite de fonctionner sans mauvaise surprise.

mv sbin/init{,.old}

sbin/init:

#!/bin/sh

# Montage des pseudos systèmes de fichier
/bin/mount -n -t proc none /proc
/bin/mount -n -t sysfs none /sys
mount -a

# arrêt/démarrage des services
/etc/rc.d/syslog-ng start
/etc/rc.d/network start
/etc/rc.d/sshd start
 
# Attente de la mise mort de la machine
rm -rf /.dead
> /.running
#agetty -8 38400 tty linux &
#sh
while [ -f /.running ]; do
    sleep 1
done
 
# Arrêt des services
/etc/rc.d/sshd stop
/etc/rc.d/network stop
/etc/rc.d/syslog-ng stop

kill -15 -1 &> /dev/null
# Démontage des systèmes de fichier
umount /proc
umount /sys
#umount /dev/shm
umount -a
mv sbin/halt{,.old}

sbin/halt:

#!/bin/sh
# le sleep permet de quitter le ssh
(sleep 2; rm /.running ) &

Personnellement, j’ai aussi modifié bin/arch et bin/uname pour avoir une réponse cohérente vu que l’environnement sera en 32 bits:

mv bin/arch{,.old}
#!/bin/sh
echo "i686"
mv bin/uname{,.old}
#!/bin/sh
uname.old "$@" | sed 's|x86_64|i686|g'

Il reste à modifier les fichiers etc/rc.conf, etc/hosts.allow pour les informations de l’environnement, le réseau et l’accès depuis l’hôte.

Avant d’accéder à l’environnement avec lxc, il faut modifier le mot de passe du root pour pouvoir y accéder depuis ssh:

# mkarchroot -r bash /var/lib/lxc/arch32/rootfs
mounting sysfs : /sys
mounting procfs : /proc
binding device nodes : /dev
binding pacman cache : /var/cache/pacman
copying mtab : /etc/mtab
copying resolv.conf : /etc/resolv.conf
starting chroot (bash)
[root@host /]# passwd
Entrez le nouveau mot de passe UNIX : 
Retapez le nouveau mot de passe UNIX : 
passwd : le mot de passe a été mis à jour avec succès
[root@host /]# exit
cleaning up mounts
#

L’environnement est normalement près, mais avant, il faut monter un périphérique spécial pour lxc:

mkdir /cgroup
mount -t cgroup cgroup /cgroup

et voilà, il ne reste plus qu’à lancer le tout:

lxc-start -n arch32
:: Starting Syslog-NG                                                    [DONE] 
:: Starting Network                                                      [DONE] 
:: Starting Secure Shell Daemon                                          [DONE]
$ ssh root@192.168.1.230
root@192.168.1.230's password: 
Last login: Mon Oct 12 10:23:42 2009 from localhost
[root@arch32 ~]# halt

Voilà, c’est un point de départ, les conteneurs ne se bornent bien sûr pas à seulement lancer un chroot, le fichier de configuration peut être bien plus complet que ça en autorisant seulement l’accès à certaines ressources.
Une fois le fonctionnement cerné, j’essaierai de faire un article dessus si quelqu’un ne s’y est pas attelé entre temps.

Un LXC HowTo (en) que j’ai découvert grâce au commentaire de l’auteur: Dwight Schauer; ça va un peu plus loin que la simple pratique.
Ainsi que la demande d’intégration d’un patch pour configurer un pont plus aisément:
FS#16625

Plymouth sur Archlinux

Un des développeurs de Chakra Project, drf, a réussi à rendre compatible Plymouth avec Archlinux, et avec [intlink id= »38″ type= »post »]KMS[/intlink], ça donne un résultat tout à fait raisonable.

Afin de tester ou d’adopter:

git clone git://git.chakra-project.org/chakra/plymouth
cd plymouth
makepkg --skipinteg -i

Créer un profile pour une image initrd, /etc/mkinitcpio-pl.conf, exemple:

MODULES="intel_agp drm i915"
HOOKS="base udev plymouth autodetect lvm2 sata filesystems"

Et /etc/mkinitcpio.d/kernel26-pl.preset:

source /etc/mkinitcpio.d/kernel26.kver
PRESETS=('default')
default_config="/etc/mkinitcpio-pl.conf"
default_image="/boot/kernel26-pl.img"

Rajouter une entrée grub démarrant la bonne image, pour grub2 par exemple:

menuentry "Arch Linux KMS Plymouth" {
linux /vmlinuz26 root=/dev/mapper/diskg-volroot ro  resume=/dev/mapper/diskg-volswap i915.modeset=1 splash quiet
initrd /kernel26-pl.img
}

Définir un thème plymouth:

plymouth-set-default-theme solar

Générer l’image:

mkinitcpio -p kernel26-pl

Et il ne reste plus qu’à redémarrer et apprécier !

Topic sur le forum archlinux.org

Ajouter une barre de progression à ‘cp’

Si vous vous êtes déjà posé la question de pourquoi diable cp ne propose pas de barre de progression, vous êtes au bon endroit (quoique ça ne doit sûrement pas être le seul) 🙂

cp lors d’une copie et à moins de lui donner l’option -v est muet comme une tombe, mais il peut être nécessaire ou au minimum rassurant d’afficher une barre de progression surtout quand on a pas d’environnement graphique. Pour cela, il suffit de se servir de strace, awk, du tout ça mélangés dans du bash.

strace permet de suivre tout appel système fait par la commande donnée en paramètre, mais surtout, il permet de filtrer ce qu’on surveille, cp n’étant en fin de compte qu’un programme qui écrit dans un fichier, il faudra surveiller tout appel à write, un exemple:

$ dd if=/dev/zero of=file_test count=100K bs=1
102400+0 enregistrements lus
102400+0 enregistrements écrits
102400 octets (102 kB) copiés, 0,521373 s, 196 kB/s
$ strace -e write cp file_test /dev/null
write(4, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 32768) = 32768
write(4, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 32768) = 32768
write(4, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 32768) = 32768
write(4, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 4096) = 4096
$

L’important dans la sortie de strace est le dernier chiffre qui correspond au nombre d’octets écrits:
32768 * 3 + 4096 = 102400

Voilà, il n’y a plus qu’à faire une petite fonction qui détecte la taille de ce qu’on veut copier, qui somme les valeurs en fin de ligne et transformer tout ça en barre de progression.

cp_p()
{
	local params=( "$@" )
	# Le dernier champs est la destination
	unset params[$(( ${#params[@]} - 1 ))]
	# $COLUMNS correspond à la largeur de votre terminal
	# et est mise à jour après chaque commande si l'option
	# checkwinsize est définie ou à la réception du signal WINCH
	kill -s WINCH $$
	[ $COLUMNS -lt 20 ] && (cp -a -- "$@"; return $?)
	lim=$(( $COLUMNS - 10 ))
	# Les "--" sont là pour signifier qu'il n'y a pas d'options
	# sinon, il faut modifier le "du" etc...
	# J'utilise le "-a" pour pouvoir copier par exemple des
	# répertoires sans soucis.
	strace -e write cp -a -- "$@" 2>&1 |
		awk '{
			count += $NF	# rajoute la valeur du dernier champs
			# 10 représente la fréquence d affichage
			if (count % 10 == 0)
			{
				percent = count / total_size * 100
				printf "%3d%% [", percent
				for (i=0;i<=percent*'$lim'/100;i++)
					printf "="
				if (percent<100)
 					printf ">"
				for (j=i;j< '$lim';j++)
					printf " "
				printf "]\r"
			}
		}
		END { printf "100\n" }' \
		total_size=$(du -bc "${params[@]}" | awk 'END {print $1}') \
		count=0
}

Une fois la fonction dans le ~/.bashrc:

$ cp_p file_test /dev/null
100% [==============================================]

source.

Vim, souris, ssh

On peut être utilisateur depuis longtemps d’une application en passant à côté de certaines options de configuration toute bêtes.
En ce qui concerne vim, il y a deux choses que je traîne depuis longtemps sans avoir vraiment pris le temps de chercher, l’ouverture de documents au travers de ssh et l’utilisation de la souris à distance.

Pour la souris, le problème, c’est de faire des recherches sur le net sans pour autant lire la première source d’informations qu’est l’aide.
Le souci est tout simple, je veux pouvoir utiliser la souris sur une session ssh avec vim, scroller, copier/coller, placer le curseur …, pour cela, il faut spécifier le mode « a » à la variable mouse:

:set mouse=a

Mais cela enlève la possibilité d’interagir avec le presse-papier en local, en lisant un peu plus loin dans l’aide, je vois qu’il suffit d’appuyer sur « shift » puis copier ou coller pour l’avoir. Alors effectivement, c’est pas grand chose, mais ça faisait partie des petits rien très gênant pour ma part.

Pour pouvoir éditer un fichier depuis un ordinateur distant avec vim/ssh:

vim scp://utilisateur@hote/chemin_vers_fichier

Par contre, ça suppose que vous avez configuré une connexion avec clé publique/privée et sans phrase de passe.
Si toutefois, vous protégez votre clé par une phrase de passe, il suffit de faire appel à ssh-agent:

ssh-agent vim

Dans vim:

:!ssh-add

Il vous demandera la phrase de passe mais une seule fois.