portfolio_hugo/content/post/pmbootstrap_custom_build/index.md

---
title: Compiler un paquet Postmarket OS
description: Installation de pmbootstrap et compilation d'un paquet Postmarket OS
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.

_Met à jour le repository [pmaports.git](https://wiki.postmarketos.org/wiki/Pmaports.git) cloné en local._
```bash
pmbootstrap pull
```
> 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.

_Met à jour le cache de la commande APK depuis l'environnement de travail_
```bash
pmbootstrap update
```
> L'environnement de travail se situe par défaut dans le dossier `$HOME/.local/var/pmbootstrap/`


_Supprime le dossier de la commande chroot_
```bash
pmbootstrap zap
```
> 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.
> Ça évite de devoir faire une VM ou un container Linux juste pour changer quelque fichier.
>
> Dans notre cas, il correspond au système de notre téléphone pour le configuré avant de l'installer ou de le tester sur notre appareil.
>
> Par défaut, il se situe dans le dossier `$HOME/.local/var/pmbootstrap/cache_git/pmaports/`

_[Optionnel] Changer la branche du repo [pmaports.git](https://wiki.postmarketos.org/wiki/Pmaports.git)_
```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

Pour compiler le paquet, on utilise la commande `pmbootstrap build [paquet_name]`.
> Avant de compiler depuis le repository Nightly, il faut d'abord rajouter la clef de signature
>
> `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

_Exemple de commande_
```bash
pmbootstrap \
  -mp https://nightly.postmarketos.org/plasma-mobile/packages/ \
  -mp http://mirror.postmarketos.org/postmarketos/ \
  --details-to-stdout \
  -j 32 \
  -t 3600 -v \
  build plasma-mobile \
  --src $home/plasma-mobile/ \
  --arch aarch64 \
  -i \
  -n
```

Dans cet exemple, j'ai utilisé les arguments suivants:

* `-mp` : Permet de définir un repository Alpine pour installer les paquets.
> Dans l'exemple, j'utilise deux repos
> 
> `https://nightly.postmarketos.org/plasma-mobile/packages/` : Contient la version en cours de développement de KDE Plasma Mobile
> 
> `http://mirror.postmarketos.org/postmarketos/` : Le miroir officiel de Postmarket OS

* `--details-to-stdout` : Affiche les logs stocké dans le fichier dans la console
* `-j N` : Défini le nombre core utilisé pour la compilation
> Dans mon cas, 32 core sur mon CPU.
* `-t [En seconde]` : Le nombre de secondes sans nouveau log dans le fichier avant d'abandonner la compilation
> Changé par 3600 secondes, car plasma-mobile est assez long à compilé et il ne génère aucun log.
* `-v` : Mode verbeux pour les logs dans le fichier
* `--src` : Change les sources du paquet. Par défaut ce sont les sources définies dans le fichier `APKBUILD`
> Pour ma part, je souhaite utiliser mon propre code pour tester
* `--arch [arch]` : L'architecture CPU du téléphone
> Pour ma part, mon téléphone est en arm64v8 donc `aarch64`
* `-n` : Permet d'éviter de compiler les dépendances du paquet.
> En général, ce n'est pas recommandé par Alpine, mais dans mon cas, je souhaite utiliser les dépendances depuis le repo
> miroir officiel de Postmarket OS.
* `-i` : Permet de dire de compiler uniquement les dépendances du paquet défini dans le fichier `APKBUILD`
> Dans mon cas, il vient en complément de l'option `-n`, ça me permet de m'assurer de ne rien build.
> Sans cette option, il risque de compiler les sous-dépendances du paquet comme le noyau Linux.

Pour 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 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.