Memorizzazione nella cache dei pacchetti APT nel flusso di lavoro Azioni GitHub

Uso il seguente flusso di lavoro di azioni Github per il mio progetto C. Il flusso di lavoro termina in ~ 40 secondi, ma più della metà del tempo viene impiegato per l'installazione del valgrindpacchetto e delle sue dipendenze.

Credo che la cache possa aiutarmi ad accelerare il flusso di lavoro. Non mi dispiace aspettare un paio di secondi in più, ma questo sembra solo uno spreco inutile delle risorse di 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'esecuzione sudo apt-get install -y valgrindinstalla i seguenti pacchetti:

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

So che le azioni supportano la memorizzazione nella cache di una directory specifica (e ci sono già molte domande e articoli SO su questo con risposta), ma non sono sicuro di dove finiscano tutti i diversi pacchetti installati da apt. Presumo /bin/o /usr/bin/non sono le uniche directory interessate dall'installazione dei pacchetti.

Esiste un modo elegante per memorizzare nella cache i pacchetti di sistema installati per future esecuzioni del flusso di lavoro?

Lo scopo di questa risposta è mostrare come è possibile eseguire la memorizzazione nella cache con le azioni github. Non necessariamente per mostrare come memorizzare nella cache valgrind, cosa che mostra, ma anche per mostrare che non tutto può / dovrebbe essere memorizzato nella cache, e devono essere presi in considerazione i compromessi della memorizzazione nella cache e del ripristino di una cache rispetto alla reinstallazione della dipendenza.

Farai uso actions/cachedell'azione per fare questo.

Aggiungilo come passaggio (prima di utilizzare valgrind):

- name: Cache valgrind
  uses: actions/cache@v1.0.3
  id: cache-valgrind
  with:
      path: "~/valgrind"
      key: ${{secrets.VALGRIND_VERSION}}

Il passaggio successivo dovrebbe tentare di installare la versione cache se presente o installare dai repository:

- 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

Spiegazione

Imposta il VALGRIND_VERSIONsegreto come output di:

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

questo ti permetterà di invalidare la cache quando viene rilasciata una nuova versione semplicemente modificando il valore del segreto.

dpkg -L valgrindviene utilizzato per elencare tutti i file installati durante l'utilizzo sudo apt-get install valgrind.

Ciò che ora possiamo fare con questo comando è copiare tutte le dipendenze nella nostra cartella 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/

inoltre

Oltre a copiare tutti i componenti di valgrind, potrebbe anche essere necessario copiare le dipendenze (come libcin questo caso), ma non consiglio di continuare lungo questo percorso perché la catena delle dipendenze cresce da lì. Per essere precisi, le dipendenze necessarie per copiare per avere finalmente un ambiente adatto a valgrind per funzionare sono le seguenti:

• libc6
• libgcc1
• gcc-8-base

Per copiare tutte queste dipendenze, è possibile utilizzare la stessa sintassi di cui sopra:

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

Tutto questo lavoro vale davvero la pena quando valgrindin primo luogo tutto ciò che è necessario per installare è semplicemente eseguire sudo apt-get install valgrind? Se il tuo obiettivo è velocizzare il processo di compilazione, devi anche prendere in considerazione la quantità di tempo necessaria per ripristinare (scaricare ed estrarre) la cache e semplicemente eseguire nuovamente il comando per installare valgrind.

E infine per ripristinare la cache, supponendo che sia archiviata in /tmp/valgrind, è possibile utilizzare il comando:

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

Il che sostanzialmente copierà tutti i file dalla cache alla partizione root.

Oltre al processo sopra, ho anche un esempio di "memorizzazione nella cache di valgrind" installandolo e compilandolo dal sorgente. La cache ora ha una dimensione di circa 63 MB (compressa) e si deve ancora installare separatamente libcquale tipo di sconfigge lo scopo.

Riferimenti:

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

È possibile creare un'immagine docker con valgrindpreinstallato ed eseguirne il flusso di lavoro.

Crea un Dockerfilecon qualcosa come:

FROM ubuntu

RUN apt-get install -y valgrind

Costruiscilo e spingilo su dockerhub:

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

Quindi utilizzare qualcosa di simile al seguente come flusso di lavoro:

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

Completamente non testato, ma hai l'idea.