portfolio_hugo/content/post/pmbootstrap_custom_build/index.md

---
title: Compiler un paquet Postmarket OS
description: Installation de pmbootstrap pour la compilation d'un paquet Postmarket OS. OS basé sur Alpine pour téléphone mobile.
slug: pmbootstrap-own-paquet
date: 2024-02-18 00:00:00+0000
categories:
    - Linux
tags:
    - Postmarket OS
weight: 1       # You can add weight to some posts to override the default sorting (date descending)
---

## À propos de Postmarket OS

[Postmarket OS](https://postmarketos.org/) est une distribution basée sur [Alpine](https://www.alpinelinux.org/) conçut pour fonctionner sur téléphone, tablette
ou sur Raspberry PI.
La communauté autour du projet propose un ensemble d'outils comme `pmbootstrap` qui permet de configurer et d'installer Postmarket OS sur son téléphone.
On peut aussi l'utiliser pour compiler son propre paquet et l'installer sur son téléphone facilement.

## Configuration de notre environnement de travail

Avant de pouvoir l'utiliser, il faut d'abord l'installer depuis ce [lien](https://wiki.postmarketos.org/wiki/Pmbootstrap).

Une fois installé et configuré, il faut d'abord préparer son environnement de travail.
Il est parfois nécessaire de mettre à jour le repository pmaports en local.
On peut le faire assez facilement avec la commande :

```bash
pmbootstrap pull
```
_Met à jour le repository [pmaports.git](https://wiki.postmarketos.org/wiki/Pmaports.git) cloné en local._
> Le repo pmaports.git stocke tous les paquets Alpine avec le fichier `APKBUILD` utilisé par le serveur de compilation.
>
> Le fonctionnement est similaire à `PKGBUILD` pour les utilisateurs de [Archlinux](https://archlinux.org/)
>
> Ce fichier contient toute la procédure pour préparer les sources, compiler le paquet depuis les sources, le numéro de version
> ainsi que la procédure pour vérifier si le paquet fonctionne correctement.
> Généralement on utilise les tests du projet comme les tests unitaires ou les tests fonctionnels.

On peut également mettre à jour le cache de la commande `apk` même si c'est pas forcément obligatoire.
```bash
pmbootstrap update
```
_Met à jour le cache de la commande APK depuis l'environnement de travail_
> L'environnement de travail se situe par défaut dans le dossier `$HOME/.local/var/pmbootstrap/`

Si on a déjà un environnement de travail en cours et qu'il contient du cache ou un travail en cours, on peut le réinitialiser assez facilement avec la commande :
```bash
pmbootstrap zap
```
_Supprime le dossier de la commande chroot pour repartir de 0_
> La commande chroot permet de changer la racine Linux.
> Par exemple, on peut faire `chroot $HOME/mon_dossier` et à partir de ce moment-là, `/` pointera vers `$HOME/mon_dossier` dans notre shell actuel.
>
> C'est très utilisé par pmbootstrap pour configurer le système Alpine.

Pour ceux qui veulent utiliser une autre branche, on peut également changer la branche disponible sur le repository.
```bash
git -C $workdir checkout [branch]
```
> `$workdir` par défaut se situe dans le dossier `$HOME/.local/var/pmbootstrap/cache_git/pmaports/`
> 
> Exemple de branche utile : `kde-nightly`

## Compilation de notre paquet Alpine

Maintenant, on va pouvoir compiler n'importe quel paquet avec la commande.
```bash
pmbootstrap build [nom_du_paquet]
```

Par exemple, on peut compiler plasma-mobile (Attention le paquet est long à compiler)
```bash
pmbootstrap build plasma-mobile
```

Par défaut, pmbootstrap va recompiler l'intégralité des dépendances du projet pour s'assurer que notre test sera reproductible.
Cependant, lorsque l'on souhaite juste tester un truc, ça peut-être ultra long.

On peut donc utiliser deux options pour nous aider:
* `-i` Permet de dire de compiler uniquement les dépendances du paquet défini dans le fichier `APKBUILD`
* `-n` Permet d'éviter de compiler les dépendances du paquet défini dans le fichier `APKBUILD`

Avec le combot des deux options, ça nous évite de tout recompiler.

On a aussi l'option `-mp` qui peut-être pratique pour changer de mirroir si le téléchargement est lent ou si l'on souhaite télécharger des paquets nightly.
> Un mirroir est un serveur utilisé pour télécharger les dépendances

On utilise cette option de cette manière:

```bash
pmbootstrap \
  -mp https://nightly.postmarketos.org/plasma-mobile/packages/ \
  -mp http://mirror.postmarketos.org/postmarketos/
```

On a aussi d'autres options comme:

* `--details-to-stdout` : Affiche le fichier de log dans la console
* `-j N` : Défini le nombre de core CPU utilisé pour la compilation
* `-t [En seconde]` : Le nombre de secondes sans nouveau log dans le fichier avant d'abandonner la compilation
* `--src` : Change les sources du paquet. Par défaut ce sont les sources définies dans le fichier `APKBUILD`
* `--arch [arch]` : L'architecture CPU du téléphone

Un exemple concret d'une commande que j'ai utilisé pour recompiler ma version de plasma-mobile avec mes changements.

```bash
pmbootstrap \
  -mp https://nightly.postmarketos.org/plasma-mobile/packages/ \
  -mp http://mirror.postmarketos.org/postmarketos/ \
  --details-to-stdout \
  -j 32 \ # Pour utiliser toute la puissance de mon CPU
  -t 3600 -v \ # La compilation est ultra longue donc pmbootstrap abandonne la build avant la fin de la compilation
  build plasma-mobile \
  --src $home/plasma-mobile/ \
  --arch aarch64 \ # Mon téléphone utilise l'architecture aarch64 (ARM64)
  -i \
  -n
```

> **Attention**
>
> Avant de compiler depuis le repository Nightly, il faut d'abord rajouter la clef de signature
>
> ```bash
> wget https://nightly.postmarketos.org/plasma-mobile/pmos@local-662fcd2f.rsa.pub
> mv pmos@local-662fcd2f.rsa.pub $(pmbootstrap config work)/config_apk_keys/
> ```
>
> Source : https://wiki.postmarketos.org/wiki/Nightly

Si vous souhaitez avoir plus d'informations, il suffit de taper la commande

```bash
pmbootstrap build --help
```

Et pour avoir les arguments généraux

```bash
pmbootstrap --help
```

## Envoie du paquet compilé sur le téléphone

Une fois le paquet compilé, il suffit de demander à `pmbootstrap` de l'envoyer sur notre téléphone via la connexion SSH.
Avec `pmbootstrap`, on utilise la commande `sideload` comme dans l'exemple ci-dessous.

```bash
pmbootstrap sideload plasma-mobile \
  --host [SSH HOST] \
  --port [SSH PORT] \
  --user [SSH USER] \
  --arch [ARCH] \
  --install-key
```

On a les arguments suivants :

* `--host [SSH HOST]` (Ex: 192.168.1.1)
* `--port [SSH PORT]` (Ex: 22)
* `--user [SSH USER]` (Ex: 192.168.1.1)
* `--arch [ARCH]` : Permet de modifier la valeur définie pour le téléphone (Ex : aarch64)
* `--install-key` : Permet d'installer la clef utilisée pour la vérification des paquets de la machine actuelle.
> Tout gestionnaire de paquet comme APK, vérifie si le paquet est valide par rapport à la signature électronique du mainteneur du paquet.
> Dans notre cas, la signature ne sera pas valide, car le paquet n'est pas compilé par le mainteneur original donc il suffit de rajouter notre signature.

Pour revenir en arrière, il suffit de taper la commande ci-dessous depuis le téléphone ou depuis la connexion SSH
```bash
sudo apk upgrade -a
```
> APK va réinstaller les paquets depuis les repos officiels.

En cas de problème liée à des conflits de fichier, on peut utiliser cette commande
```bash
sudo apk fix --force
```
> Cette commande va forcer APK à écraser les fichiers en conflit.