Mr. S.

Membre

Installer rationnellement Arch linux en ligne de commande

Bonjour tout le monde,

Introduction :

Mr. S. est de retour !

Avec cette fois ci, un canevas relatif à une installation facile d’une « base » Arch linux en ligne de commande !

Lisez bien le sommaire, car il ocnstitue à lui seul un pense-bète !

Sommaire :

Introduction
Préambule
1 / Télécharger l'iso
2 / Création du média d'installation
* Graver l'iso sur un cd-rom
* Flasher une clef usb
3 / Vérification du média usb
4 / Modifier le bios de votre PC afin de régler la priorité de démarrage
5 / Booter sur le média et incarner le rôle de root (mode prompt)
6 / Francisation du clavier
7 / Partitionnement des disques avec une table de partitions de type "MS-DOS" (MBR)
8 / Formatage des partitions
9 / Création des points de montage
10 / Chrooter le système afin de travailler dans le futur système à installer
11 / Définir le miroir de téléchargement de vos paquets
12 / Installation de la base
13 / Télécharger quelques utilitaires
14 / Création du fichier fstab
15 / Installation du chargeur de démarrage
16 / Configuration du futur système Arch
* Pour une utilisation franco-française
* Pour une utilisation franco-belge (wallonne)
* Pour une utilisation franco-canadienne (québecoise)
* Pour une utilisation franco-luxembourgeoise
* Pour une utilisation franco-suisse (helvète)
Pour configurer la localisation nationale
* Pour la France
* Pour la Belgique
* Pour le Canada
* Pour le Luxembourg
* Pour le Confédération helvétique
17 / Générer les traductions
18 / Dénommer votre machine
19 / Installer le fuseau horaire franco-français, c’est-à-dire celui de Paris (via la création d’un lien symbolique)
20 / Appliquer l’horaire UTC
21 / Générer le fichier de configuration de Grub
22 / Configurer le fichier de configuration Grub
23 / Installer le Grub
24 / Création du mot de passe root
25 / Installer la mise en service du réseau pour le redémarrage
26 / Autoriser la mise en service du réseau pour le redémarrage
27 / Configurer le miroir pour utiliser les bibliothèques 32 bits
28 / Sortir du chroot, pour redémarrer et configurer finalement le système
29 / Démonter toutes les partitions
30 / Rédémarer
31 / Configurer la séquence boot de votre ordinateur
32 / mise à jour des dépôts
33 / Disposer des logs en clair
34 / Configurer le son
35 / Installer tous les greffons multimédias possibles et imaginables
36 / Installer xorg
37 / Installation des polices de caractères
38 / Installation des paquets relatifs aux applications graphiques
39 / installer tous les pilotes d’impression possibles et imaginables
40 / Installer le scanner
41 / Installer de quoi écrire, compter, dessiner, créer/gérer une base de données, créer ou modifier un pdf
42 / Installer un fureteur internet
43 / Installer un client de messagerie universel (le plus polyvalent qui soit)
44 / Création du ou des utilisateurs de votre système Arch linux
45 / Activation des services
* gestion des fichiers d’enregistrement d’activité
* programmes récurrents
* impression
* bluetooth
* synchronisation de l’horaire en réseau
46 / Installer Xfce, car léger et complet
* ajout perso : ranger, i3, openbox (...)
47 / Agencer votre clavier
48 / Rendre fonctionnel votre environnement XFCE
* lancement du service lightdm
* autoriser l’usage du service lightdm
49 / Améliorer le graphisme de votre XFCE
50 / Stabiliser votre installation Arch
Conclusion
Sources
Annexes
* Annexe n° 1 : script zsh-completion
* Annexe n° 2 : pacstrap.in
* Annexe n° 3 : genfstab.in
* Annexe n° 4 : common
* Annexe n° 5 : arch-chroot.in
* Annexe n° 6 : test_valid_nulber_of_base / dossier test
* Annexe n° 7 : test_option_twiddling / dossier test
* Annexe n°8 : test_mangle / dossier test
* Annexe n° 9 : common (deuxième du genre) / dossier test

Préambule :

Tutoriel, cela signifierait « faîtes ceci », alors que canevas cela signifie « quoi faire » ! Je préfère canevas… car Arch se conçoit et se construit comme une rolling release, donc ce qui s’écrit un jour, se désécrit le lendemain !

Il s'agit donc de construire morceau par morceau un système unix « Arch » qui vous ressemble et qui soit le plus léger possible. En effet, qui veut voyager loin ménage sa monture, d'où l'intérêt d'en mettre le moins possible, en matière de paquets et de dépôts...

Ce n’est pas si difficile que cela d’installer une base Arch. J’ai bien écrit plus haut une base Arch, pas un système complexe !  Simplement de quoi travailler pour écrire, dessiner, compter, lire ses courriels, fureter sur l’internet, bref un usage quotidien de l’outil informatique posé sur notre table. Pour un usage plus complexe, du style GED-SAE, Sql, et compagnie, il convient d’aller voir ailleurs, c’est-à-dire à se plonger dans les wikis divers et variés, ce que je ferai pas car je n’en ai pas le besoin personnel !

Ce canevas n’aborde délibérément aucun ajout de matériel que ce soit ou toute spécificité lié à tel matériel. Ce n’est pas son objet. Idem pour une installation UEFI / secure boot / dual boot / multiboot avec ou pas windows et/ou Mac… et que sais-je encore. Pour tout cela, je vous renvoie aux wikis officiels des options concernés, voir aux tutoriels à foison sur l’internet. Tous plus ou moins plombés d’ailleurs… Y compris pour une installation Arch de base, d’où ce canevas !

Il ne s'agit donc pas de recréer en ligne de commande / tty ... une installation experte façon debian, mais de réaliser une installation qui tienne la route, à la façon d'une maison, avec ses fondations, ses murs, son grenier, son toit, et enfin ses réseaux de fluides (eau, gaz edf ...).

Archlinux étant une distribution en évolution permanente (rolling release), il s'avère dangereux de suivre tel ou tel tutoriel. A contrario suivre une liste de mots-clefs relatifs à l'installation de telle ou telle partie logique et indispensable d'un système d'exploitation informatique me semble judicieux.

C'est la piste que je vous propose de suivre. Cette démarche empirique vous permettra d'installer Archlinux quelque soit son état de dévelopement ou les dépôts utilisés. L'essentiel consiste à comprendre, puis apprendre et enfin à partager.

Je ne peux que vous inviter à vous renseigner, à lire les wikis, à questionner les forums, à interroger les anciens qui ont déjà réussi une telle expérience, ... et à vous armer de patience. Il m'a fallu 6 ou 7 tentatives avant de réussir !

Ces mots-clefs vont appeler Arch Install Scripts https://github.com/falconindy/arch-install-scripts, scripts bash destinés à automatiser certaines tâches, mais pas votre indépendance d'esprit !

Liste des mots-clefs : iso, bios, clavier, réseau, horaire, partition, miroirs, chroot, base, configuration, grub, interface graphique, xfce, openbox, i3, logiciels, LibreOffice, ...

J’insiste : cette présentation ne portera que sur une installation en mode bios et monoboot uniquement, car c'est ce que j'ai opéré. Pour le reste, reportez vous au wiki officiel !

Pour cette rédaction, je me suis servi de l’iso téléchargeable à l’url suivante : http://mir.archlinux.fr/iso/latest/en 64 Bbits.

Il existe également une iso 32 bits non testée par mes soins téléchargeable à l’url suivante : https://mirror.archlinux32.org/archisos/

Merci à Iohan du club  Le Libre Vanvéen (LLV), sans qui je n’aurai jamais découvert Arch et qui m’a montré à quoi cela ressemblait et m’a donné le goût de « Archer ».

=> Installer une base Arch revient à respecter plusieurs étapes logiques et obligatoires, mais dont certaines peuvent s’effectuer parfois dans le désordre. Attention, selon les versions d’Arch, certains termes pourront changer, de même que telle ou telle manip. D’où l’intérêt de vous tenir au courant, via les wikis et autres forums d’utilisateurs. Ne recopiez pas bêtement ce que je vous livre ici comme retour d’expérience ! Comprenez, apprenez puis partagez !

Arrêtons de bavasser et débutons !

1 / Télécharger l'iso :

L'iso se télécharge par exemple ici en x86_64 (64 bits) http://mir.archlinux.fr/iso/ ou https://archlinux32.org/ en i386 (32 bits). L'iso est dîte hybride, c'est-à-dire autant gravable sur CD/DVD que flashable sur un support usb de votre choix. Cette iso comprend les arch scripts qui vont vous faciliter un peu la vie, mais pas que. Cette iso ne permet toutefois d'installer un système x86_64 que par le réseau, fini l'installation hors-ligne !

2 / Création du média d'installation :

* Graver l'iso sur un cd-rom :

=> A l’aide la commande mkisofs, après vous être placé en root :

mkisofs -r -T -o archlinux-2018.02.01-x86_64.iso

ou également à l’aide de « cdrecord » :

cdrecord -v speed=4 dev=0,3,0 -multi archlinux-2018.02.01-x86_64.iso

ou également (et je m’arrête là) :

wodim dev=/dev/sr0 -eject archlinux-2018.02.01-x86_64.iso

que je vous conseille !

* Flasher une clef usb :

dd if=/chemin/vers/ archlinux-2018.02.01-x86_64.iso of=/dev/sdx bs=1M

que j’utilise habituellement et où x représente votre support usb à flasher ; dasn le cas où un seul support usb est branché, ce sera probablement "sdb". A vérifier cependant !

3 / Vérification du média usb :

Intégrité - Authenticité - Vérification sous Arch -  Vérification par gpg à faire : je ne fournis aucunne information car je n'ai pas procédé à cette étape, "faisant confiance au système", c’est rare !

Pour vérifier votre iso, reportez vous au wiki officiel, si vous choisissez d'effectuer cette étape.

4 / Modifier le bios de votre PC afin de régler la priorité de démarrage. Votre PC doit démarrer ultérieurement sur la clé USB ou sur le CD, et non pas sur le HDD.

5 / Booter sur le média et incarner le rôle de root (mode prompt) :
=> Arrivée directe en console avec identification en root

root@archiso ~ #

6 / Francisation du clavier :

loadkeys fr

=> Pour une autre langue :

find /usr/share/kbd/keymaps/ -type f

7 / Partitionnement des disques avec une table de partitions de type "MS-DOS" (MBR)

=> Volontairement, je n'ai pas utilisé de partitionnement GUID (GPT) avec UEFI de manière à me simplifier la vie. Je ne fournis donc aucune information à ce sujet. Pour cela, je vous renvoie au wiki officiel.

=> Une partition de type MBR limite le nombre de partitions primaires installées à 4. Ce qui donne chez moi à l'aide de l'outil « cfdisk » :

/dev/sda1 pour le /boot 0,5 Go pour y installer plusieurs noyaux,
/dev/sda2 pour la swap = 8 Go pour l'hibernation, les traitements gourmands en mémoire (compilation, retouche photos, montage vidéos, big data...)
/dev/sda3 pour le / = 35 Go pour être à l'aise, façon chargeur de FAMAS chargé à 10 ou 15 bastos...  pour une capacité réelle de 30,
/dev/sda4 pour le /home = le reste !

8 / Formatage des partitions : à l'aide de la commande mkfs."alias" ; où alias représente un type de partitionnement. mkfs.ext2 pour un partitionnement en ext2, mkfs.ext3 pour un partitionnement en ext3. mkfs.ext4 pour un partitionnement en ext4... 

Chez moi :

mkfs.ext2 /dev/sda1
mkfs.ext4 /dev/sda3
mkfs.ext4 /dev/sda4

Pour créer la partition swap, utiliser les commandes « mkswap » (création), puis « swapon » (activation) :

mkswap /dev/sda2
swapon /dev/sda2

9 / Création des points de montage :

mount /dev/sda3 /mnt
mkdir /mnt/{boot,home}
mount /dev/sda1 /mnt/boot
mount /dev/sda4 /mnt/home

10 / Chrooter le système afin de travailler dans le futur système à installer

arch-chroot /mnt

11 / Définir le miroir de téléchargement de vos paquets :

nano /etc/pacman.d/mirrorlist

« mir.archlinux.fr » (chez moi) pour un usage franco-français. Dans le cas contraire, vous allez galérer. Il vaut mieux ne pas perdre du temps précieux et de la bande passante trop utile.

12 / Installation de la base : utiliser la commande « pactrap » et non « pacman », car « pacman » installerai les paquets en ram et pas en chroot. La commande « pacman » est utilisée plus tard !

pacstrap /mnt base base-devel

« base-devel » est sensé fournir le dépôt AUR. Chez moi cela n’a pas fonctionné, mais je m’en fous car je ne l’utilise pas et j’explique pourquoi plus loin !

13 / Télécharger quelques utilitaires à installer dans le futur système, et non en ram (d’où pacstrap et pas pacman!)

pacstrap /mnt linux-lts zip unzip p7zip vim mc alsa-utils syslog-ng mtools dosfstools lsb-release ntfs-3g exfat-utils

14 / Création du fichier fstab :

genfstab -U -p /mnt >> /mnt/etc/fstab

15 / Installation du chargeur de démarrage :

pacstrap /mnt grub os-prober

16 / Configuration du futur système Arch :

=> Il faut impérativement passer en « mode chroot », « chrooter », soit « change-root »

arch-chroot /mnt

Avant d’aller plus loin, voici quelques infos pratiques. Cela concerne les pays francophones comme la Belgique, la Suisse, le Luxembourg ou encore le Canada francophone.

Nous allons par la suite créer des fichiers qui demanderont des valeurs précises. Les voici résumées ici :

* Pour une utilisation franco-française :

nano /etc/vconsole.conf

Saisir les valeurs suivantes :

KEYMAP=fr-latin9
FONT=lat9w-16

* Pour une utilisation franco-belge (wallonne) :

nano /etc/vconsole.conf

Saisir les valeurs suivantes :

KEYMAP=be-latin1
FONT=lat9w-16

* Pour une utilisation franco-canadienne (québecoise) :

nano /etc/vconsole.conf

Saisir les valeurs suivantes :

KEYMAP=cf
FONT=lat9w-16

* Pour une utilisation franco-luxembourgeoise :

nano /etc/vconsole.conf

Saisir les valeurs suivantes :

KEYMAP=fr-latin9
FONT=lat9w-16

* Pour une utilisation franco-suisse (helvète) :

nano /etc/vconsole.conf

Saisir les valeurs suivantes :

KEYMAP=fr_CH-latin1
FONT=lat9w-16

=> https://forums.archlinux.fr/viewtopic.php?t=14387

Pour configurer la localisation nationale :

nano /etc/locale.conf

Saisir les valeurs suivantes :

* Pour la France :

LANG=fr_FR.UTF-8

ou

echo LANG="fr_FR.UTF-8" > /etc/locale.conf

=>  Décommenter la ligne « fr_FR.UTF-8 UTF-8 » dans le fichier « /etc/locale.gen »

* Pour la Belgique :

LANG=fr_BE.UTF-8

ou

echo LANG="fr_BE.UTF-8" > /etc/locale.conf

=>  Décommenter la ligne « fr_BE.UTF-8 UTF-8 » dans le fichier « /etc/locale.gen »

* Pour le Canada :

LANG=fr_CA.UTF-8

ou

echo LANG="fr_CA.UTF-8" > /etc/locale.conf

=>  Décommenter la ligne « fr_CA.UTF-8 UTF-8 » dans le fichier « /etc/locale.gen »

* Pour le Luxembourg :

LANG=fr_LU.UTF-8

ou

echo LANG="fr_LU.UTF-8" > /etc/locale.conf

=>  Décommenter la ligne « fr_LU.UTF-8 UTF-8 » dans le fichier « /etc/locale.gen »

* Pour le Confédération helvétique :

LANG=fr_CH.UTF-8

ou

echo LANG="fr_CH.UTF-8" > /etc/locale.conf

=>  Décommenter la ligne « fr_CH.UTF-8 UTF-8 » dans le fichier « /etc/locale.gen »

17 / Générer les traductions :

locale-gen

=> On peut spécifier la locale pour la session courante, à modifier en fonction de votre pays :

/ pour la France, ce sera

export LANG=fr_FR.UTF-8

/ pour la Belgique, ce sera

export LANG=fr_BE.UTF-8

/ pour le Luxembourg, ce sera

export LANG=fr_LU.UTF-8

/ pour le Canada francophone, ce sera

export LANG=fr_CA.UTF-8

/ pour la Suisse, ce sera

export LANG=fr_CH.UTF-8

18 / Dénommer votre machine :

nano /etc/hostname

=> Chez moi, cela donne

stevie@livarch ~]$

, contraction de Livarp et de Arch linux. Ah ! Ma vénérée Livarp 031-032-xxs(twm !)-039-04-Livarp-Yotus, puis recyclée en KissOS !

19 / Installer le fuseau horaire franco-français, c’est-à-dire celui de Paris (via la création d’un lien symbolique) :

ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime

20 / Appliquer l’horaire UTC :

hwclock --systohc --utc

21 / Générer le fichier de configuration de Grub. Et compiler le noyau (à faire au moins une fois dans sa vie !) :

mkinitcpio -p linux

dans le cadre d’une compilation d’un noyau non-lts (fortement déconseillé, car le début des emmerdes…)

mkinitcpio -p linux linux-lts

dans le cadre d’une compilation d’un noyau lts (fortement conseillé car participe de la stabilisation de la base Arch installée !

22 / Configurer le fichier de configuration Grub :

grub-mkconfig -o /boot/grub/grub.cfg

23 / Installer le Grub :

grub-install --no-floppy --recheck /dev/sda

24 / Création du mot de passe root :

passwd root

25 / Installer la mise en service du réseau pour le redémarrage (vous fonctionnez actuellement sur le réseau de l’iso, pas celui du futur système actuellement en cours de construction – configuration dans le chroot!) :
=> Chez moi : usage de  « networkmanager ».

pacman -Syy networkmanager

26 / Autoriser la mise en service du réseau pour le redémarrage (vous fonctionnez actuellement sur le réseau de l’iso, pas celui du futur système actuellement en cours de construction – configuration dans le chroot!) :

systemctl enable NetworkManager

27 / Configurer le miroir pour utiliser les bibliothèques 32 bits :

nano /etc/pacman.d/mirrorlist

=> Modifier la ligne « multilib » en conséquence.

28 / Sortir du chroot, pour redémarrer et configurer finalement le système :

exit

29 / Démonter toutes les partitions :

umount -R /mnt

30 / Rédémarer :

reboot

31 / Configurer la séquence boot de votre ordinateur :

=> Sortez d’un démarrage en usb ou cd pour un démarrage en HDD.

=> Ouverture du pc en tty : saisissez à nouveau le mot de passe root qui vous est demandé, car vous êtes de nouveau connecté en « root », « user » viendra plus tard.

32 / mise à jour des dépôts :

pacman -Syu

  ou

pacman -Syy

je ne sais plus. Vérifiez vous même ! et non plus pacstrap, car vous n’êtes plus en chroot, mais dans votre vrai système en dur qu’il convient de fignoler pour qu’il fonctionne au doigt et à l’oeil !

33 / Disposer des logs en clair :

* ouvrir le fichier « /etc/systemd/journald.conf »

nano /etc/systemd/journald.conf

* remplacer la ligne 

#ForwardToSyslog=no

par la ligne

ForwardToSyslog=yes

34 / Configurer le son :

* lancer le programme « alsamixer » et configurer en semi-graphique selon vos besoins :

alsamixer

* fermer le programme « alsamixer » :

* verrouiller votre configuration :

alsactl store

35 / Installer tous les greffons multimédias possibles et imaginables (j’y suis allé franco sans trop regarder ni à la bande passante, ni à ce qui était superflu, de peur de me retrouver sur le sable le cas échéant) :

pacman -S gst-plugins-{base,good,bad,ugly} gst-libav

36 / Installer xorg :

pacman -S xorg-{server,xinit,apps} xf86-input-{mouse,keyboard} xf86-input-libinput  xf86-video-vesa  xdg-user-dirs

37 / Installation des polices de caractères :

pacman -S ttf-{bitstream-vera,liberation,freefont,dejavu} freetype2

=> Pour les autres polices de caractères, j’ai triché en les copiant-collant depuis Livarp-Yotus et Viperr Fedora remix

38 / Installation des paquets relatifs aux applications graphiques :

pacman -S cups gimp gimp-help-fr hplip python-pyqt5

39 / installer tous les pilotes d’impression possibles et imaginables, histoire de ne pas se retrouver sur le sable… :

pacman -S foomatic-{db,db-ppds,db-gutenprint-ppds,db-nonfree,db-nonfree-ppds} gutenprint

40 / Installer le scanner :

pacman -S xsane

41 / Installer de quoi écrire, compter, dessiner, créer/gérer une base de données, créer ou modifier un pdf (…) LibreOffice quoi !

pacman -S libreoffice-still-fr

42 / Installer un fureteur internet  :

pacman -S firefox-i18n-fr

43 / Installer un client de messagerie universel (le plus polyvalent qui soit) :

pacman -S thunderbird-i18n-fr

Volà de quoi travailler correctement pour un usage normal et familial.

44 / Création du ou des utilisateurs de votre système Arch linux :

useradd -m -g wheel -c 'user' -s /bin/bash user

puis saisir le mot de passe du nouvel utilisateur:

passwd user

45 / Activation des services :

* gestion des fichiers d’enregistrement d’activité :

systemctl enable syslog-ng@default

* programmes récurrents :

systemctl enable cronie

* impression :

systemctl enable avahi-daemon

puis

systemctl enable avahi-dnsconfd

puis

systemctl enable org.cups.cupsd

* bluetooth (si besoin) :

systemctl enable bluetooth

Chez moi, cela donne :

[stevie@livarch ~]$ su
Mot de passe : 
[root@livarch stevie]# systemctl enable avahi-daemon
[root@livarch stevie]# systemctl enable avahi-dnsconfd
[root@livarch stevie]# systemctl enable org.cups.cupsd
[root@livarch stevie]# systemctl enable cronie
[root@livarch stevie]# systemctl enable syslog-ng@default
Created symlink /etc/systemd/system/multi-user.target.wants/syslog-ng@default.service → /usr/lib/systemd/system/syslog-ng@.service.
[root@livarch stevie]# systemctl enable bluetooth
Created symlink /etc/systemd/system/dbus-org.bluez.service → /usr/lib/systemd/system/bluetooth.service.
Created symlink /etc/systemd/system/bluetooth.target.wants/bluetooth.service → /usr/lib/systemd/system/bluetooth.service.

* synchronisation de l’horaire en réseau :

systemctl enable ntpd

46 / Installer Xfce, car léger et complet :

pacman -S xfce4 xfce4-goodies gvfs-{afc,goa,google,gphoto2,mtp,nfs,smb} smplayer quodlibet python2-pyinotify lightdm-gtk-greeter xarchiver claws-mail galculator evince ffmpegthumbnailer xscreensaver pavucontrol pulseaudio pulseaudio-alsa libcanberra-{pulse,gstreamer} system-config-printer thunderbird-i18n-fr networkmanager network-manager-applet  lightdm-gtk-greeter-settings

* ajout perso : ranger, i3, openbox (...)

pacman -S obconf lxappearance-obconf obmenu

et

pacman -S i3

47 / Agencer votre clavier :

* connectez vous en root :

su

* modifier l’agencement du clavier :

localectl set-x11-keymap fr

48 / Rendre fonctionnel votre environnement XFCE :

* lancement du service lightdm (en root) :

systemctl start lightdm

* autoriser l’usage du service lightdm (en root) :

systemctl enable lightdm

49 / Améliorer le graphisme de votre XFCE :

=> Télécharger les sources des icones et thèmes Sardi mis au point par Erik DuBois et son équipe aux adresses suivantes :

https://github.com/erikdubois
https://archmerge.com/
https://sourceforge.net/projects/archmerge/
https://sourceforge.net/projects/sardi/ … z/download
https://github.com/erikdubois/Arc-Theme-Colora

plus la « gamme » numix :

https://github.com/numixproject
https://github.com/numixproject/numix-gtk-theme
https://github.com/numixproject/numix-icon-theme-circle
https://github.com/numixproject/numix-icon-theme

En un mot à la soupe ! Je cite ce que j’ai installé, le reste ne m’intéresse pas pour cette rédaction.

Cela demande du taf, mais bon pour être beau, grand et fort, il convient de souffrir un peu !

P.S. : Vous aurez noté. Ici pas de dépôt AUR, que du main à la Livarp-Yotus. Parano quand tu nous tiens. D’où « pacman » comme gestionnaire de paquets et pas « yaourt » !

50 / Stabiliser votre installation Arch :

A priori, Arch linux s'avère particulièrement stable en raison du cycle rapide rapport de problème/résolution et de l'utilisation de code source en amont non modifié.

Cependant, seule une installation proprement configurée vous procurera une installation stable au sens propre du terme.

Je ne peux que parler de ce je connais ou ai effectué sur ma plate-fome Arch.

J'ai fait le choix d'une partition "/" de plus de 35 Go pour me trouver à l'aise, garder la liberté d'installer les programmes que je souhaitais, quelque soientleur taille, mais aussi pouvoir stocker le cas échéant les anciens paquets, liberté de rétrogradation des paquets.

J'évite systématiquement les paquets non-officiels (AUR, ...) et encore plus les paquets en développement, tant pis pour les utilisateurs de confiances (trusted users), mais je ne fais confiance qu'aux paquets officiels testés sérieusement puisqu'engageant la responsabilité de la distribution et la crédibilité du staff Arch. Essuyer les plâtres, c'est pour les autres ! Il faut se tenir à jour concernant l'efficience des miroirs. A contrario, il faut privilégier les paquets les plus usuels et dûment testés. Donc pas de paquets testing, AUR ...

Idem pour les pilotes non-libres. Il faut privilégier les pilotes libres, laisser tomber ce qui est « privateur », donc opaque pas essence ! N'oubliez pas que si vous avez choisi Arch, ce n'est pas pour faire du Ubuntu, distribution conçue pour que cela marche, et non pas pou maintenir coûte que coûte la liberté et l'indépendance de ses utilisateurs.

Concernant la mise à jour de votre système Arch, il vous faut absolument vous renseigner en permanence, par une veille documentaire relative aux alertes de mises à jour ou de sécurité, voir de de dépréciation de tel ou tel paquet. 

Il convient donc d'utiliser des miroirs les plus à jour possibles. L'automatisation des mises à jour (via des tâches "cron") peut donc entraîner une instabilité de votre système, alors que vous devez simultanément instaurer une mise à jour régulière du-dit système... à l'aide de la commande

pacman -Syu

 !

Privilégier un noyau LTS, plutôt qu'une version exotique, fut-elle à la "mode". Le noyau LTS bénéficie d'un soutien de longue durée (Long Term Support). Vous serez seul dans votre tombe !

Quelque soit votre gestionnaire de paquets, vous devez être capable de rétrograder un paquet risquant de déstabiliser votre système (d'où la plus grande partition "/" possible, soit 35 Go communément admis) dans le wiki officiel et sur certains posts de forums.

Il convient également de sauvegarder non seulement la base de données des paquets installés, mais également vos fichiers de configuration (avant leur édition) . Dans l'absolu, il vous faudrait également assurer la sauvegarde des répertoires /etc, /home, /srv et /var.

Soit :
/home: les données du ou des utilisateurs.
/srv: relatif aux serveurs.
/var: les données de vos applications actuellement utilisées ou de pacman...
/etc : fichiers de configuration de votre système

Peu le font, mais il le faudrait toutefois !

Maintenant, la simple logique vous conduira à comprendre que la parano, façon OpenBSD (j'ai utilisé OpenBSD) ne vous protégera nullement d'un problème. A contrario, en adoptant une hygiène informatique élémentaire, vous doublerez les chances de vous sortir avec le moins de casse possible des faux pas qui guettent tout utilisateur d'un ordinateur, quelque soit son système d'ailleurs !

Pacman vous permet d'éviter des conflits entre les paquets installés et candidats à votre HDD, ce que ne permettrait pas une installation manuelle. Celle-ci vous conduira inévitablement à des erreurs ou à des oublis !

Conclusion :

En gros, vous allez vous retrouver avec un installation Arch, mais sans avoir utilisé un installateur automatique. En cas de soucis ou de crash, vous devriez savoir vous en sortir. La ligne de commande apprend à reconstruire sans forcément tout réinstaller à chaque problème.

Cela demande du taf, mais bon pour être beau, grand et fort, il convient de souffrir un peu !

Vous avez construit morceau par morceau un système unix « Arch » qui vous ressemble et qui s’avère le plus léger possible. Votre pied s’est posé sur l’étrier !

Par ailleurs, qui veut voyager loin, ménage sa monture, d'où l'intérêt d'en mettre le moins possible, en matière de paquets et de dépôts...

Enfin, un grand merci à Iohan pour m'avoir mis le pied à l'étrier d'Arch.

Sources :

- Wiki Arch Linux :

https://wiki.archlinux.fr/installation

- Scripts d’Arch linux :

https://github.com/falconindy/arch-install-scripts

- Tutoriel de Frédérci BEZIES :

http://frederic.bezies.free.fr/blog/?page_id=9453

- Tutoriel de Jérémy VILLET :

https://www.supinfo.com/articles/single … linux-base

- Tutoriel de P3ter :

https://p3ter.fr/installer-et-configurer-archlinux.html

- Arch wiki relatif à Openbox :
https://wiki.archlinux.fr/openbox

- Se faire son propre environnement léger avec Archlinux et Openbox :

http://frederic.bezies.free.fr/blog/?p=6630

- Building a Custom Linux Environment With Openbox, by  John Ramsden

https://ramsdenj.com/2016/03/28/buildin … enbox.html

- Wiki Arch linux relatif à I3 : 

https://wiki.archlinux.org/index.php/i3

- Clavier suisse :

https://forums.archlinux.fr/viewtopic.php?t=14387

- Icones et thèmes Sardi mis au point par Erik DuBois et son équipe aux adresses suivantes :

https://github.com/erikdubois
https://archmerge.com/
https://sourceforge.net/projects/archmerge/
https://sourceforge.net/projects/sardi/ … z/download
https://github.com/erikdubois/Arc-Theme-Colora

- Produits « numix » :

https://github.com/numixproject
https://github.com/numixproject/numix-gtk-theme
https://github.com/numixproject/numix-icon-theme-circle
https://github.com/numixproject/numix-icon-theme

Annexes

Annexe n° 1 : script zsh-completion

#compdef pacstrap genfstab arch-chroot

_pacstrap_args=(
    '-h[display help]'
)

_pacstrap_args_nonh=(
    '(-h --help)-c[Use the package cache on the host, rather than the target]'
    '(-h --help)-d[Allow installation to a non-mountpoint directory]'
    '(--help -h)-i[Avoid auto-confirmation of package selections]'
)


# builds command for invoking pacman in a _call_program command - extracts
# relevant options already specified (config file, etc)
# $cmd must be declared by calling function
_pacman_get_command() {
	# this is mostly nicked from _perforce
	cmd=( "pacman" "2>/dev/null")
	integer i
	for (( i = 2; i < CURRENT - 1; i++ )); do
		if [[ ${words[i]} = "--config" || ${words[i]} = "--root" ]]; then
			cmd+=( ${words[i,i+1]} )
		fi
	done
}

# provides completions for packages available from repositories
# these can be specified as either 'package' or 'repository/package'
_pacman_completions_all_packages() {
	local -a cmd packages repositories packages_long
	_pacman_get_command

	if compset -P1 '*/*'; then
		packages=( $(_call_program packages $cmd[@] -Sql ${words[CURRENT]%/*}) )
		typeset -U packages
		_wanted repo_packages expl "repository/package" compadd ${(@)packages}
	else
		packages=( $(_call_program packages $cmd[@] -Sql) )
		typeset -U packages
		_wanted packages expl "packages" compadd - "${(@)packages}"

		repositories=(${(o)${${${(M)${(f)"$(</etc/pacman.conf)"}:#\[*}/\[/}/\]/}:#options})
		typeset -U repositories
		_wanted repo_packages expl "repository/package" compadd -S "/" $repositories
	fi
}

_pacstrap_none(){
    _arguments -s : \
        "$_pacstrap_args[@]" \
        "$_longopts[@]" \
}

_genfstab_args=(
    '-h[display help]'
)
_genfstab_args_nonh=(
    '(--help -h)-p[Avoid printing pseudofs mounts]'
    '(-U --help -h)-L[Use labels for source identifiers]'
    '(-L --help -h)-U[Use UUIDs for source identifiers]'
)

_arch_chroot_args=( '-h[display help]' )

_longopts=( '--help[display help]' )

_pacstrap(){
    if [[ -z ${(M)words:#--help} && -z ${(M)words:#-h} ]]; then
        case $words[CURRENT] in
            -c*|-d*|-i*)
                _arguments -s "$_pacstrap_args_nonh[@]"
                ;;
            -*)
                _arguments -s : \
                    "$_pacstrap_args[@]" \
                    "$_pacstrap_args_nonh[@]" \
                    "$_longopts[@]"
                ;;
            --*)
                _arguments -s : \
                    "$_longopts[@]"
                ;;
            *)
                _arguments -s : \
                    "$_pacstrap_args[@]" \
                    "$_pacstrap_args_nonh[@]" \
                    "$_longopts[@]" \
                    ":*:_path_files -/" \
                    ":*:_pacman_completions_all_packages"
                ;;
        esac
    else
        return 1
    fi
}

_genfstab(){
    if [[ -z ${(M)words:#--help} && -z ${(M)words:#-*h} ]]; then
        case $words[CURRENT] in
            -p*|-L*|-U*)
                _arguments -s : \
                    "$_genfstab_args_nonh[@]"
                ;;
            -*)
                _arguments -s : \
                    "$_genfstab_args[@]" \
                    "$_genfstab_args_nonh[@]" \
                    "$_longopts[@]"
                ;;
            --*)
                _arguments -s : \
                    "$_longopts[@]"
                ;;
            *)
                _arguments \
                    "$_genfstab_args[@]" \
                    "$_genfstab_args_nonh[@]" \
                    "$_longopts[@]" \
                    ":*:_path_files -/"
                ;;
        esac
    else
        return 1
    fi
}

_arch_chroot(){
    if [[ -z ${(M)words:#--help} && -z ${(M)words:#-*h} ]]; then
        case $words[CURRENT] in
            -*)
                _arguments -s : \
                    "$_arch_chroot_args[@]" \
                    "$_longopts[@]" \
                ;;
            --*)
                _arguments -s : \
                    "$_longopts[@]"
                ;;
            *)
                _arguments \
                    ':*:_path_files -/'
                ;;
        esac
    else
        return 1
    fi
}

_install_scripts(){
    case "$service" in
        pacstrap)
            _pacstrap "$@"
            ;;
        genfstab)
            _genfstab "$@";;
        arch-chroot)
            _arch_chroot "$@";;
        *)
            _message "Error";;
    esac
}

_install_scripts "$@"

Annexe n° 2 : pacstrap.in

#!/bin/bash

#
# Assumptions:
#  1) User has partitioned, formatted, and mounted partitions on /mnt
#  2) Network is functional
#  3) Arguments passed to the script are valid pacman targets
#  4) A valid mirror appears in /etc/pacman.d/mirrorlist
#

shopt -s extglob

m4_include(common)

hostcache=0
copykeyring=1
copymirrorlist=1

usage() {
  cat <<EOF
usage: ${0##*/} [options] root [packages...]

  Options:
    -C config      Use an alternate config file for pacman
    -c             Use the package cache on the host, rather than the target
    -d             Allow installation to a non-mountpoint directory
    -G             Avoid copying the host's pacman keyring to the target
    -i             Avoid auto-confirmation of package selections
    -M             Avoid copying the host's mirrorlist to the target

    -h             Print this help message

pacstrap installs packages to the specified new root directory. If no packages
are given, pacstrap defaults to the "base" group.

EOF
}

if [[ -z $1 || $1 = @(-h|--help) ]]; then
  usage
  exit $(( $# ? 0 : 1 ))
fi

(( EUID == 0 )) || die 'This script must be run with root privileges'

while getopts ':C:cdGiM' flag; do
  case $flag in
    C)
      pacman_config=$OPTARG
      ;;
    d)
      directory=1
      ;;
    c)
      hostcache=1
      ;;
    i)
      interactive=1
      ;;
    G)
      copykeyring=0
      ;;
    M)
      copymirrorlist=0
      ;;
    :)
      die '%s: option requires an argument -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
    ?)
      die '%s: invalid option -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
  esac
done
shift $(( OPTIND - 1 ))

(( $# )) || die "No root directory specified"
newroot=$1; shift
pacman_args=("${@:-base}")

if (( ! hostcache )); then
  pacman_args+=(--cachedir="$newroot/var/cache/pacman/pkg")
fi

if (( ! interactive )); then
  pacman_args+=(--noconfirm)
fi

if [[ $pacman_config ]]; then
  pacman_args+=(--config="$pacman_config")
fi

[[ -d $newroot ]] || die "%s is not a directory" "$newroot"
if ! mountpoint -q "$newroot" && (( ! directory )); then
  die '%s is not a mountpoint!' "$newroot"
fi

# create obligatory directories
msg 'Creating install root at %s' "$newroot"
mkdir -m 0755 -p "$newroot"/var/{cache/pacman/pkg,lib/pacman,log} "$newroot"/{dev,run,etc}
mkdir -m 1777 -p "$newroot"/tmp
mkdir -m 0555 -p "$newroot"/{sys,proc}

# mount API filesystems
chroot_setup "$newroot" || die "failed to setup chroot %s" "$newroot"

msg 'Installing packages to %s' "$newroot"
if ! pacman -r "$newroot" -Sy "${pacman_args[@]}"; then
  die 'Failed to install packages to new root'
fi

if (( copykeyring )); then
  # if there's a keyring on the host, copy it into the new root, unless it exists already
  if [[ -d /etc/pacman.d/gnupg && ! -d $newroot/etc/pacman.d/gnupg ]]; then
    cp -a /etc/pacman.d/gnupg "$newroot/etc/pacman.d/"
  fi
fi

if (( copymirrorlist )); then
  # install the host's mirrorlist onto the new root
  cp -a /etc/pacman.d/mirrorlist "$newroot/etc/pacman.d/"
fi

# vim: et ts=2 sw=2 ft=sh:

Annexe n° 3 : genfstab.in

#!/bin/bash

shopt -s extglob

m4_include(common)

write_source() {
  local src=$1 spec= label= uuid= comment=()

  label=$(lsblk -rno LABEL "$1" 2>/dev/null)
  uuid=$(lsblk -rno UUID "$1" 2>/dev/null)

  # bind mounts do not have a UUID!

  case $bytag in
    '')
      [[ $uuid ]] && comment=("UUID=$uuid")
      [[ $label ]] && comment+=("LABEL=$(mangle "$label")")
      ;;
    LABEL)
      spec=$label
      [[ $uuid ]] && comment=("$src" "UUID=$uuid")
      ;;
    UUID)
      spec=$uuid
      comment=("$src")
      [[ $label ]] && comment+=("LABEL=$(mangle "$label")")
      ;;
    *)
      [[ $uuid ]] && comment=("$1" "UUID=$uuid")
      [[ $label ]] && comment+=("LABEL=$(mangle "$label")")
      [[ $bytag ]] && spec=$(lsblk -rno "$bytag" "$1" 2>/dev/null)
      ;;
  esac

  [[ $comment ]] && printf '# %s\n' "${comment[*]}"

  if [[ $spec ]]; then
    printf '%-20s' "$bytag=$(mangle "$spec")"
  else
    printf '%-20s' "$(mangle "$src")"
  fi
}

optstring_apply_quirks() {
  local varname=$1 fstype=$2

  # SELinux displays a 'seclabel' option in /proc/self/mountinfo. We can't know
  # if the system we're generating the fstab for has any support for SELinux (as
  # one might install Arch from a Fedora environment), so let's remove it.
  optstring_remove_option "$varname" seclabel

  # Prune 'relatime' option for any pseudofs. This seems to be a rampant
  # default which the kernel often exports even if the underlying filesystem
  # doesn't support it. Example: https://bugs.archlinux.org/task/54554.
  if awk -v fstype="$fstype" '$1 == fstype { exit 1 }' /proc/filesystems; then
    optstring_remove_option "$varname" relatime
  fi

  case $fstype in
    f2fs)
      # These are Kconfig options for f2fs. Kernels supporting the options will
      # only provide the negative versions of these (e.g. noacl), and vice versa
      # for kernels without support.
      optstring_remove_option "$varname" noacl,acl,nouser_xattr,user_xattr
      ;;
    vfat)
      # Before Linux v3.8, "cp" is prepended to the value of the codepage.
      if optstring_get_option "$varname" codepage && [[ $codepage = cp* ]]; then
        optstring_remove_option "$varname" codepage
        optstring_append_option "$varname" "codepage=${codepage#cp}"
      fi
      ;;
  esac
}

usage() {
  cat <<EOF
usage: ${0##*/} [options] root

  Options:
    -L             Use labels for source identifiers (shortcut for -t LABEL)
    -p             Exclude pseudofs mounts (default behavior)
    -P             Include pseudofs mounts
    -t TAG         Use TAG for source identifiers
    -U             Use UUIDs for source identifiers (shortcut for -t UUID)

    -h             Print this help message

genfstab generates output suitable for addition to an fstab file based on the
devices mounted under the mountpoint specified by the given root.

EOF
}

if [[ -z $1 || $1 = @(-h|--help) ]]; then
  usage
  exit $(( $# ? 0 : 1 ))
fi

while getopts ':LPpt:U' flag; do
  case $flag in
    L)
      bytag=LABEL
      ;;
    U)
      bytag=UUID
      ;;
    P)
      pseudofs=1
      ;;
    p)
      pseudofs=0
      ;;
    t)
      bytag=${OPTARG^^}
      ;;
    :)
      die '%s: option requires an argument -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
    ?)
      die '%s: invalid option -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
  esac
done
shift $(( OPTIND - 1 ))

(( $# )) || die "No root directory specified"
root=$(realpath -mL "$1"); shift

if ! mountpoint -q "$root"; then
  die "$root is not a mountpoint"
fi

# handle block devices
findmnt -Recvruno SOURCE,TARGET,FSTYPE,OPTIONS,FSROOT "$root" |
    while read -r src target fstype opts fsroot; do
  if (( !pseudofs )) && fstype_is_pseudofs "$fstype"; then
    continue
  fi

  # default 5th and 6th columns
  dump=0 pass=2

  src=$(unmangle "$src")
  target=$(unmangle "$target")
  target=${target#$root}

  if (( !foundroot )) && findmnt "$src" "$root" >/dev/null; then
    # this is root. we can't possibly have more than one...
    pass=1 foundroot=1
  fi

  # if there's no fsck tool available, then only pass=0 makes sense.
  if ! fstype_has_fsck "$fstype"; then
    pass=0
  fi

  if [[ $fsroot != / ]]; then
    if [[ $fstype = btrfs ]]; then
      opts+=,subvol=${fsroot#/}
    else
      # it's a bind mount
      src=$(findmnt -funcevo TARGET "$src")$fsroot
      if [[ $src -ef $target ]]; then
        # hrmm, this is weird. we're probably looking at a file or directory
        # that was bound into a chroot from the host machine. Ignore it,
        # because this won't actually be a valid mount. Worst case, the user
        # just re-adds it.
        continue
      fi
      fstype=none
      opts+=,bind
      pass=0
    fi
  fi

  # filesystem quirks
  case $fstype in
    fuseblk)
      # well-behaved FUSE filesystems will report themselves as fuse.$fstype.
      # this is probably NTFS-3g, but let's just make sure.
      if ! newtype=$(lsblk -no FSTYPE "$src") || [[ -z $newtype ]]; then
        # avoid blanking out fstype, leading to an invalid fstab
        error 'Failed to derive real filesystem type for FUSE device on %s' "$target"
      else
        fstype=$newtype
      fi
      ;;
  esac

  optstring_apply_quirks "opts" "$fstype"

  # write one line
  write_source "$src"
  printf '\t%-10s' "/$(mangle "${target#/}")" "$fstype" "$opts"
  printf '\t%s %s' "$dump" "$pass"
  printf '\n\n'
done

# handle swaps devices
{
  # ignore header
  read

  while read -r device type _ _ prio; do
    options=defaults
    if [[ $prio != -1 ]]; then
      options+=,pri=$prio
    fi

    # skip files marked deleted by the kernel
    [[ $device = *'\040(deleted)' ]] && continue

    if [[ $type = file ]]; then
      printf '%-20s' "$device"
    elif [[ $device = /dev/dm-+([0-9]) ]]; then
      # device mapper doesn't allow characters we need to worry
      # about being mangled, and it does the escaping of dashes
      # for us in sysfs.
      write_source "$(dm_name_for_devnode "$device")"
    else
      write_source "$(unmangle "$device")"
    fi

    printf '\t%-10s\t%-10s\t%-10s\t0 0\n\n' 'none' 'swap' "$options"
  done
} </proc/swaps

# vim: et ts=2 sw=2 ft=sh:

Annexe n° 4 : common

# generated from util-linux source: libmount/src/utils.c
declare -A pseudofs_types=([anon_inodefs]=1
                           [autofs]=1
                           [bdev]=1
                           [binfmt_misc]=1
                           [cgroup]=1
                           [cgroup2]=1
                           [configfs]=1
                           [cpuset]=1
                           [debugfs]=1
                           [devfs]=1
                           [devpts]=1
                           [devtmpfs]=1
                           [dlmfs]=1
                           [fuse.gvfs-fuse-daemon]=1
                           [fusectl]=1
                           [hugetlbfs]=1
                           [mqueue]=1
                           [nfsd]=1
                           [none]=1
                           [pipefs]=1
                           [proc]=1
                           [pstore]=1
                           [ramfs]=1
                           [rootfs]=1
                           [rpc_pipefs]=1
                           [securityfs]=1
                           [sockfs]=1
                           [spufs]=1
                           [sysfs]=1
                           [tmpfs]=1)

# generated from: pkgfile -vbr '/fsck\..+' | awk -F. '{ print $NF }' | sort
declare -A fsck_types=([cramfs]=1
                       [exfat]=1
                       [ext2]=1
                       [ext3]=1
                       [ext4]=1
                       [ext4dev]=1
                       [jfs]=1
                       [minix]=1
                       [msdos]=1
                       [reiserfs]=1
                       [vfat]=1
                       [xfs]=1)

out() { printf "$1 $2\n" "${@:3}"; }
error() { out "==> ERROR:" "$@"; } >&2
msg() { out "==>" "$@"; }
msg2() { out "  ->" "$@";}
die() { error "$@"; exit 1; }

ignore_error() {
  "$@" 2>/dev/null
  return 0
}

in_array() {
  local i
  for i in "${@:2}"; do
    [[ $1 = "$i" ]] && return 0
  done
  return 1
}

chroot_add_mount() {
  mount "$@" && CHROOT_ACTIVE_MOUNTS=("$2" "${CHROOT_ACTIVE_MOUNTS[@]}")
}

chroot_maybe_add_mount() {
  local cond=$1; shift
  if eval "$cond"; then
    chroot_add_mount "$@"
  fi
}

chroot_setup() {
  CHROOT_ACTIVE_MOUNTS=()
  [[ $(trap -p EXIT) ]] && die '(BUG): attempting to overwrite existing EXIT trap'
  trap 'chroot_teardown' EXIT

  chroot_add_mount proc "$1/proc" -t proc -o nosuid,noexec,nodev &&
  chroot_add_mount sys "$1/sys" -t sysfs -o nosuid,noexec,nodev,ro &&
  ignore_error chroot_maybe_add_mount "[[ -d '$1/sys/firmware/efi/efivars' ]]" \
      efivarfs "$1/sys/firmware/efi/efivars" -t efivarfs -o nosuid,noexec,nodev &&
  chroot_add_mount udev "$1/dev" -t devtmpfs -o mode=0755,nosuid &&
  chroot_add_mount devpts "$1/dev/pts" -t devpts -o mode=0620,gid=5,nosuid,noexec &&
  chroot_add_mount shm "$1/dev/shm" -t tmpfs -o mode=1777,nosuid,nodev &&
  chroot_add_mount run "$1/run" -t tmpfs -o nosuid,nodev,mode=0755 &&
  chroot_add_mount tmp "$1/tmp" -t tmpfs -o mode=1777,strictatime,nodev,nosuid
}

chroot_teardown() {
  umount "${CHROOT_ACTIVE_MOUNTS[@]}"
  unset CHROOT_ACTIVE_MOUNTS
}

try_cast() (
  _=$(( $1#$2 ))
) 2>/dev/null

valid_number_of_base() {
  local base=$1 len=${#2} i=

  for (( i = 0; i < len; i++ )); do
    try_cast "$base" "${2:i:1}" || return 1
  done

  return 0
}

mangle() {
  local i= chr= out=
  local {a..f}= {A..F}=

  for (( i = 0; i < ${#1}; i++ )); do
    chr=${1:i:1}
    case $chr in
      [[:space:]\\])
        printf -v chr '%03o' "'$chr"
        out+=\\
        ;;
    esac
    out+=$chr
  done

  printf '%s' "$out"
}

unmangle() {
  local i= chr= out= len=$(( ${#1} - 4 ))
  local {a..f}= {A..F}=

  for (( i = 0; i < len; i++ )); do
    chr=${1:i:1}
    case $chr in
      \\)
        if valid_number_of_base 8 "${1:i+1:3}" ||
            valid_number_of_base 16 "${1:i+1:3}"; then
          printf -v chr '%b' "${1:i:4}"
          (( i += 3 ))
        fi
        ;;
    esac
    out+=$chr
  done

  printf '%s' "$out${1:i}"
}

optstring_match_option() {
  local candidate pat patterns

  IFS=, read -ra patterns <<<"$1"
  for pat in "${patterns[@]}"; do
    if [[ $pat = *=* ]]; then
      # "key=val" will only ever match "key=val"
      candidate=$2
    else
      # "key" will match "key", but also "key=anyval"
      candidate=${2%%=*}
    fi

    [[ $pat = "$candidate" ]] && return 0
  done

  return 1
}

optstring_remove_option() {
  local o options_ remove=$2 IFS=,

  read -ra options_ <<<"${!1}"

  for o in "${!options_[@]}"; do
    optstring_match_option "$remove" "${options_[o]}" && unset 'options_[o]'
  done

  declare -g "$1=${options_[*]}"
}

optstring_normalize() {
  local o options_ norm IFS=,

  read -ra options_ <<<"${!1}"

  # remove empty fields
  for o in "${options_[@]}"; do
    [[ $o ]] && norm+=("$o")
  done

  # avoid empty strings, reset to "defaults"
  declare -g "$1=${norm[*]:-defaults}"
}

optstring_append_option() {
  if ! optstring_has_option "$1" "$2"; then
    declare -g "$1=${!1},$2"
  fi

  optstring_normalize "$1"
}

optstring_prepend_option() {
  local options_=$1

  if ! optstring_has_option "$1" "$2"; then
    declare -g "$1=$2,${!1}"
  fi

  optstring_normalize "$1"
}

optstring_get_option() {
  local opts o

  IFS=, read -ra opts <<<"${!1}"
  for o in "${opts[@]}"; do
    if optstring_match_option "$2" "$o"; then
      declare -g "$o"
      return 0
    fi
  done

  return 1
}

optstring_has_option() {
  local "${2%%=*}"

  optstring_get_option "$1" "$2"
}

dm_name_for_devnode() {
  read dm_name <"/sys/class/block/${1#/dev/}/dm/name"
  if [[ $dm_name ]]; then
    printf '/dev/mapper/%s' "$dm_name"
  else
    # don't leave the caller hanging, just print the original name
    # along with the failure.
    print '%s' "$1"
    error 'Failed to resolve device mapper name for: %s' "$1"
  fi
}

fstype_is_pseudofs() {
  (( pseudofs_types["$1"] ))
}

fstype_has_fsck() {
  (( fsck_types["$1"] ))
}

Annexe n° 5 : arch-chroot.in

#!/bin/bash

shopt -s extglob

m4_include(common)

usage() {
  cat <<EOF
usage: ${0##*/} chroot-dir [command]

    -h                  Print this help message
    -u <user>[:group]   Specify non-root user and optional group to use

If 'command' is unspecified, ${0##*/} will launch /bin/bash.

EOF
}

chroot_add_resolv_conf() {
  local chrootdir=$1 resolv_conf=$1/etc/resolv.conf

  # Handle resolv.conf as a symlink to somewhere else.
  if [[ -L $chrootdir/etc/resolv.conf ]]; then
    # readlink(1) should always give us *something* since we know at this point
    # it's a symlink. For simplicity, ignore the case of nested symlinks.
    resolv_conf=$(readlink "$chrootdir/etc/resolv.conf")
    if [[ $resolv_conf = /* ]]; then
      resolv_conf=$chrootdir$resolv_conf
    else
      resolv_conf=$chrootdir/etc/$resolv_conf
    fi

    # ensure file exists to bind mount over
    if [[ ! -f $resolv_conf ]]; then
      install -Dm644 /dev/null "$resolv_conf" || return 1
    fi
  elif [[ ! -e $chrootdir/etc/resolv.conf ]]; then
    # The chroot might not have a resolv.conf.
    return 0
  fi

  chroot_add_mount /etc/resolv.conf "$resolv_conf" --bind
}

while getopts ':hu:' flag; do
  case $flag in
    h)
      usage
      exit 0
      ;;
    u)
      userspec=$OPTARG
      ;;
    :)
      die '%s: option requires an argument -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
    ?)
      die '%s: invalid option -- '\''%s'\' "${0##*/}" "$OPTARG"
      ;;
  esac
done
shift $(( OPTIND - 1 ))

(( EUID == 0 )) || die 'This script must be run with root privileges'
(( $# )) || die 'No chroot directory specified'
chrootdir=$1
shift

[[ -d $chrootdir ]] || die "Can't create chroot on non-directory %s" "$chrootdir"

chroot_setup "$chrootdir" || die "failed to setup chroot %s" "$chrootdir"
chroot_add_resolv_conf "$chrootdir" || die "failed to setup resolv.conf"

chroot_args=()
[[ $userspec ]] && chroot_args+=(--userspec "$userspec")
chroot_args+=("$chrootdir" "$@")

SHELL=/bin/bash unshare --fork --pid chroot "${chroot_args[@]}"

Annexe n° 6 : test_valid_nulber_of_base / dossier test

#!/bin/bash

. "${1:-./common}"
. ./test/common

EXPECT_success valid_number_of_base 16 feedfacebeef
EXPECT_failure valid_number_of_base 16 feedsfacebeef
EXPECT_success valid_number_of_base 16 1234567890

EXPECT_success valid_number_of_base 10 1234567890
EXPECT_failure valid_number_of_base 10 1234.567890
EXPECT_failure valid_number_of_base 10 1234567890abcdef

EXPECT_success valid_number_of_base 18 1234567890abcdefgh
EXPECT_failure valid_number_of_base 18 1234567890abcdefghi

Annexe n° 7 : test_option_twiddling / dossier test

#!/bin/bash

. "${1:-./common}"
. ./test/common

optstring=rw,relatime,fd=29,pgrp=1,timeout=300,minproto=5,maxproto=5,direct
optstring_remove_option optstring fd
optstring_remove_option optstring pgrp=400
ASSERT_streq "$optstring" 'rw,relatime,pgrp=1,timeout=300,minproto=5,maxproto=5,direct'

optstring_append_option optstring pgrp=400
optstring_append_option optstring pgrp=400
optstring_append_option optstring pgrp=400
ASSERT_streq "$optstring" 'rw,relatime,pgrp=1,timeout=300,minproto=5,maxproto=5,direct,pgrp=400'

optstring_prepend_option optstring pgrp=600
optstring_prepend_option optstring pgrp=600
optstring_prepend_option optstring pgrp=600
ASSERT_streq "$optstring" 'pgrp=600,rw,relatime,pgrp=1,timeout=300,minproto=5,maxproto=5,direct,pgrp=400'

EXPECT_success optstring_has_option optstring pgrp=400
EXPECT_success optstring_has_option optstring pgrp=1
EXPECT_success optstring_has_option optstring pgrp
EXPECT_failure optstring_has_option optstring maxproto=6
EXPECT_success optstring_has_option optstring maxproto

EXPECT_failure optstring_get_option optstring proto
EXPECT_success optstring_get_option optstring maxproto
ASSERT_streq "$maxproto" "5"
EXPECT_success optstring_get_option optstring timeout
ASSERT_streq "$timeout" "300"

optstring_remove_option optstring pgrp
ASSERT_streq "$optstring" 'rw,relatime,timeout=300,minproto=5,maxproto=5,direct'

optstring_remove_option optstring minproto,relatime
ASSERT_streq "$optstring" 'rw,timeout=300,maxproto=5,direct'

optstring_remove_option optstring ro,direct
ASSERT_streq "$optstring" 'rw,timeout=300,maxproto=5'

optstring=,,,,,,defaults,,,,rw,,,,,,minproto=5,,,
optstring_normalize optstring
ASSERT_streq "$optstring" 'defaults,rw,minproto=5'


optstring=
optstring_normalize optstring
ASSERT_streq "$optstring" 'defaults'


EXPECT_success optstring_match_option key key=val
EXPECT_success optstring_match_option key=val key=val
EXPECT_failure optstring_match_option key=val key=val2
EXPECT_failure optstring_match_option 'key=*' key=val2

Annexe n°8 : test_mangle / dossier test

#!/bin/bash

. "${1:-./common}"
. ./test/common

ASSERT_streq ' deleted' "$(unmangle "$(mangle ' deleted')")"
ASSERT_streq '\040deleted' "$(mangle "$(unmangle '\040deleted')")"
ASSERT_streq 'foo\011\040\011bar' "$(mangle $'foo\t \tbar')"

Annexe n° 9 : common (deuxième du genre) / dossier test

#!/bin/bash

fail=0
testcount=0

EXPECT_success() {
  (( ++testcount ))
  if ! "$@"; then
    (( ++fail ))
    printf 'expectation failed: did not succeed: %s\n' "$*" >&2
  fi
}

EXPECT_failure() {
  (( ++testcount ))
  if "$@"; then
    (( ++fail ))
    printf 'expectation failed: did not fail: %s\n' "$*" >&2
  fi
}

TEST_exit() {
  local result

  trap -- EXIT

  (( fail == 0 )) && result=PASS || result=FAIL

  printf '%s: %s\n' "$result" "$1"

  exit $(( fail != 0 ))
}

ASSERT_streq() {
  if [[ $1 != "$2" ]]; then
    printf 'assertion failed [line %d]: [[ %s = "%s" ]]\n' "$BASH_LINENO" "$1" "$2" >&2
  fi
}

TEST_start() {
  trap "TEST_exit '$1'" EXIT
}

TEST_start "${0##*/test_}"

IceF0x

#! Gourou Linux

Re : Installer rationnellement Arch linux en ligne de commande

Merci pour ce super tuto

petite note pour openbox, obmenu ne fonctionne plus, il faut installer obmenu3

---

Utiliser des logiciels propriétaires, c'est comme les plats préparés, on est incapable de dire les conservateurs qu'ils contiennent, on dira toujours que c'est bon, mais ça ne remplacera jamais le repas fait maison par sa maman.
]:D #! Crunchbang & Archlinux GNU/Linux User ]:D

Koala

Membre

Re : Installer rationnellement Arch linux en ligne de commande

Super merci     

Quand j'avais installé arch il y a quelques années je regrettais de devoir me servir du wiki anglais car plus fourni, avec le temps et grace a des contributions comme la tienne on arrive a trouvé tout ce qu'il faut en Fr 

Soit dit en passant ne prétez jamais un ordi sous arch a un membre de la famille sous peine de le retrouver avec plein de truc exotique venant de aur  .. m'avait fallu 2 heures pour remettre tout en place oO

Merci a toi 

ZeR0-@bSoLu

Membre

Re : Installer rationnellement Arch linux en ligne de commande

Super tuto complet

---

Mess With The Bests
Die Like The Rest