Mise en cache des packages APT dans le workflow Actions GitHub

J'utilise le workflow Actions Github suivant pour mon projet C. Le flux de travail se termine en ~ 40 secondes, mais plus de la moitié de ce temps est consacré à l'installation du valgrindpackage et de ses dépendances.

Je pense que la mise en cache pourrait m'aider à accélérer le flux de travail. Cela ne me dérange pas d'attendre quelques secondes supplémentaires, mais cela semble être un gaspillage inutile des ressources de GitHub.

name: C Workflow

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v1

    - name: make
      run: make

    - name: valgrind
      run: |
        sudo apt-get install -y valgrind
        valgrind -v --leak-check=full --show-leak-kinds=all ./bin

L'exécution sudo apt-get install -y valgrindinstalle les packages suivants:

• gdb
• gdbserver
• libbabeltrace1
• libc6-dbg
• libipt1
• valgrind

Je sais que les actions prennent en charge la mise en cache d'un répertoire spécifique (et il y a déjà plusieurs questions et articles sur les réponses à ce sujet), mais je ne sais pas où se trouvent tous les différents packages installés par apt. Je suppose /bin/ou /usr/bin/ne suis pas le seul répertoire affecté par l'installation de packages.

Existe-t-il un moyen élégant de mettre en cache les packages système installés pour les futures exécutions de workflow?

Le but de cette réponse est de montrer comment la mise en cache peut être effectuée avec des actions github. Pas nécessairement pour montrer comment mettre en cache valgrind, ce qu'il montre, mais aussi pour montrer que tout ne peut / ne doit pas être mis en cache, et les compromis de la mise en cache et de la restauration d'un cache par rapport à la réinstallation de la dépendance doivent être pris en compte.

Vous utiliserez l' actions/cacheaction pour ce faire.

Ajoutez-le comme une étape (avant d'utiliser Valgrind):

- name: Cache valgrind
  uses: actions/[email protected]
  id: cache-valgrind
  with:
      path: "~/valgrind"
      key: ${{secrets.VALGRIND_VERSION}}

L'étape suivante doit tenter d'installer la version en cache, le cas échéant, ou d'installer à partir des référentiels:

- name: Install valgrind
  env:
    CACHE_HIT: ${{steps.cache-valgrind.outputs.cache-hit}}
    VALGRIND_VERSION: ${{secrets.VALGRIND_VERSION}}
  run: |
      if [[ "$CACHE_HIT" == 'true' ]]; then
        sudo cp --verbose --force --recursive ~/valgrind/* /
      else
        sudo apt-get install --yes valgrind="$VALGRIND_VERSION"
        mkdir -p ~/valgrind
        sudo dpkg -L valgrind | while IFS= read -r f; do if test -f $f; then echo $f; fi; done | xargs cp --parents --target-directory ~/valgrind/
      fi

Explication

Définissez VALGRIND_VERSIONsecret comme la sortie de:

apt-cache policy valgrind | grep -oP '(?<=Candidate:\s)(.+)'

cela vous permettra d'invalider le cache lorsqu'une nouvelle version est publiée simplement en changeant la valeur du secret.

dpkg -L valgrindest utilisé pour répertorier tous les fichiers installés lors de l'utilisation sudo apt-get install valgrind.

Ce que nous pouvons maintenant faire avec cette commande est de copier toutes les dépendances dans notre dossier cache:

dpkg -L valgrind | while IFS= read -r f; do if test -f $f; then echo $f; fi; done | xargs cp --parents --target-directory ~/valgrind/

en outre

En plus de copier tous les composants de valgrind, il peut également être nécessaire de copier les dépendances (comme libcdans ce cas), mais je ne recommande pas de continuer sur cette voie car la chaîne de dépendances ne fait que croître à partir de là. Pour être précis, les dépendances nécessaires pour copier pour enfin avoir un environnement adapté à Valgrind pour s'exécuter sont les suivantes:

• libc6
• libgcc1
• gcc-8-base

Pour copier toutes ces dépendances, vous pouvez utiliser la même syntaxe que ci-dessus:

for dep in libc6 libgcc1 gcc-8-base; do
    dpkg -L $dep | while IFS= read -r f; do if test -f $f; then echo $f; fi; done | xargs cp --parents --target-directory ~/valgrind/
done

Est-ce que tout ce travail en vaut vraiment la peine alors que tout ce qui est nécessaire pour installer valgrinden premier lieu est de simplement exécuter sudo apt-get install valgrind? Si votre objectif est d'accélérer le processus de génération, vous devez également prendre en compte le temps qu'il faut pour restaurer (télécharger et extraire) le cache par rapport à simplement relancer la commande pour l'installer valgrind.

Et enfin pour restaurer le cache, en supposant qu'il soit stocké dans /tmp/valgrind, vous pouvez utiliser la commande:

cp --force --recursive /tmp/valgrind/* /

Ce qui copiera essentiellement tous les fichiers du cache vers la partition racine.

En plus du processus ci-dessus, j'ai également un exemple de "mise en cache de valgrind" en l'installant et en le compilant depuis la source. La taille du cache est désormais d'environ 63 Mo (compressée) et il faut encore installer séparément libcquel type de but échoue .

Références:

• https://askubuntu.com/a/408785
• /unix/83593/copy-specific-file-type-keeping-the-folder-structure

Vous pouvez créer une image docker avec valgrindpréinstallé et exécuter votre flux de travail à ce sujet.

Créez un Dockerfileavec quelque chose comme:

FROM ubuntu

RUN apt-get install -y valgrind

Construisez-le et poussez-le sur dockerhub:

docker build -t natiiix/valgrind .
docker push natiiix/valgrind

Utilisez ensuite quelque chose comme ce qui suit comme flux de travail:

name: C Workflow

on: [push, pull_request]

jobs:
  build:
    container: natiiix/valgrind

    steps:
    - uses: actions/checkout@v1

    - name: make
      run: make

    - name: valgrind
      run: valgrind -v --leak-check=full --show-leak-kinds=all ./bin

Complètement non testé, mais vous avez l'idée.